diff --git a/.eslintignore b/.eslintignore
index 298aa7585765f..29d959598349e 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -1,2 +1,5 @@
 .eslintrc.js
 jest.config.ts
+node_modules
+rust
+livestream
diff --git a/.eslintrc.js b/.eslintrc.js
index fa36af54fc983..f1af109bde41a 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -12,7 +12,7 @@ const globals = {
 }
 
 module.exports = {
-    ignorePatterns: ['node_modules', 'plugin-server'],
+    ignorePatterns: ['node_modules', 'plugin-server', 'rust', 'livestream'],
     env,
     settings: {
         react: {
diff --git a/.github/workflows/alert-on-failed-automerge.yml b/.github/workflows/alert-on-failed-automerge.yml
index af9fde9675ed4..31582b50d11c1 100644
--- a/.github/workflows/alert-on-failed-automerge.yml
+++ b/.github/workflows/alert-on-failed-automerge.yml
@@ -9,7 +9,7 @@ on:
 jobs:
     notify_on_failure:
         if: ${{ github.event.check_suite.conclusion == 'failure' }}
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         steps:
             - name: Checkout code
diff --git a/.github/workflows/automerge.yml b/.github/workflows/automerge.yml
index 20a3dbf314649..4b2a41b91384f 100644
--- a/.github/workflows/automerge.yml
+++ b/.github/workflows/automerge.yml
@@ -23,7 +23,7 @@ on:
 jobs:
     automerge:
         name: Automerge if requested
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         env:
             IS_POSTHOG_BOT_AVAILABLE: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN != '' }}
         steps:
diff --git a/.github/workflows/browserslist-update.yml b/.github/workflows/browserslist-update.yml
new file mode 100644
index 0000000000000..ff27f8d6745f2
--- /dev/null
+++ b/.github/workflows/browserslist-update.yml
@@ -0,0 +1,40 @@
+name: Update Browserslist database
+
+on:
+    schedule:
+        - cron: '0 12 * * MON'
+    workflow_dispatch:
+
+permissions:
+    contents: write
+    pull-requests: write
+
+jobs:
+    update-browserslist-database:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v3
+              with:
+                  fetch-depth: 0
+
+            - name: Configure git
+              run: |
+                  git config --global user.email "action@github.com"
+                  git config --global user.name "Browserslist Update Action"
+
+            - name: Install pnpm
+              uses: pnpm/action-setup@v4
+
+            - name: Set up Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 18.12.1
+
+            - name: Update Browserslist database and create PR if applies
+              uses: c2corg/browserslist-update-action@v2
+              with:
+                  github_token: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN }} # This token has permission to open PRs
+                  commit_message: 'build: update Browserslist db'
+                  title: 'build: update Browserslist db'
+                  labels: 'dependencies, automerge'
diff --git a/.github/workflows/ci-backend-update-test-timing.yml b/.github/workflows/ci-backend-update-test-timing.yml
index 39a1993119701..eb1c36329ce6e 100644
--- a/.github/workflows/ci-backend-update-test-timing.yml
+++ b/.github/workflows/ci-backend-update-test-timing.yml
@@ -19,7 +19,7 @@ env:
 jobs:
     django:
         name: Run Django tests and save test durations
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             - uses: actions/checkout@v3
 
diff --git a/.github/workflows/ci-backend.yml b/.github/workflows/ci-backend.yml
index 943b6611006d7..410d4deb18461 100644
--- a/.github/workflows/ci-backend.yml
+++ b/.github/workflows/ci-backend.yml
@@ -43,7 +43,7 @@ jobs:
     # Job to decide if we should run backend ci
     # See https://github.com/dorny/paths-filter#conditional-execution for more details
     changes:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         name: Determine need to run backend checks
         # Set job outputs to values from filter step
@@ -94,7 +94,7 @@ jobs:
         timeout-minutes: 30
 
         name: Python code quality checks
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         steps:
             # If this run wasn't initiated by the bot (meaning: snapshot update) and we've determined
@@ -153,7 +153,7 @@ jobs:
         timeout-minutes: 10
 
         name: Validate Django and CH migrations
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         steps:
             - uses: actions/checkout@v3
@@ -228,7 +228,7 @@ jobs:
         timeout-minutes: 30
 
         name: Django tests – ${{ matrix.segment }} (persons-on-events ${{ matrix.person-on-events && 'on' || 'off' }}), Py ${{ matrix.python-version }}, ${{ matrix.clickhouse-server-image }} (${{matrix.group}}/${{ matrix.concurrency }})
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         strategy:
             fail-fast: false
@@ -328,7 +328,7 @@ jobs:
             matrix:
                 clickhouse-server-image: ['clickhouse/clickhouse-server:24.8.7.41']
         if: needs.changes.outputs.backend == 'true'
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             - name: 'Checkout repo'
               uses: actions/checkout@v3
@@ -382,7 +382,7 @@ jobs:
     calculate-running-time:
         name: Calculate running time
         needs: [django, async-migrations]
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         if: # Run on pull requests to PostHog/posthog + on PostHog/posthog outside of PRs - but never on forks
             needs.changes.outputs.backend == 'true' &&
             (
diff --git a/.github/workflows/ci-e2e.yml b/.github/workflows/ci-e2e.yml
index 97deeffe6bd2a..4ec28981e5f1d 100644
--- a/.github/workflows/ci-e2e.yml
+++ b/.github/workflows/ci-e2e.yml
@@ -14,7 +14,7 @@ concurrency:
 
 jobs:
     changes:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         name: Determine need to run E2E checks
         # Set job outputs to values from filter step
@@ -53,7 +53,7 @@ jobs:
     chunks:
         needs: changes
         name: Cypress preparation
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         outputs:
             chunks: ${{ steps.chunk.outputs.chunks }}
@@ -67,7 +67,7 @@ jobs:
 
     container:
         name: Build and cache container image
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 60
         needs: [changes]
         permissions:
@@ -91,7 +91,7 @@ jobs:
 
     cypress:
         name: Cypress E2E tests (${{ strategy.job-index }})
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 60
         needs: [chunks, changes, container]
         permissions:
@@ -279,7 +279,7 @@ jobs:
 
     calculate-running-time:
         name: Calculate running time
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         needs: [cypress]
         if: needs.changes.outputs.shouldTriggerCypress == 'true' &&
             github.event.pull_request.head.repo.full_name == 'PostHog/posthog'
diff --git a/.github/workflows/ci-frontend.yml b/.github/workflows/ci-frontend.yml
index d466e0d3cdb82..f59c7e8eef790 100644
--- a/.github/workflows/ci-frontend.yml
+++ b/.github/workflows/ci-frontend.yml
@@ -16,7 +16,7 @@ jobs:
     # we skip each step individually, so   they are still reported as success
     # because many of them are required for CI checks to be green
     changes:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         name: Determine need to run frontend checks
         outputs:
@@ -54,7 +54,7 @@ jobs:
         name: Code quality checks
         needs: changes
         # kea typegen and typescript:check need some more oomph
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             # we need at least one thing to run to make sure we include everything for required jobs
             - uses: actions/checkout@v3
@@ -121,7 +121,7 @@ jobs:
                   minimum-change-threshold: 1000
 
     jest:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         needs: changes
         name: Jest test (${{ matrix.segment }} - ${{ matrix.chunk }})
 
diff --git a/.github/workflows/ci-hobby.yml b/.github/workflows/ci-hobby.yml
index 0025e656c8204..73d29cbdad746 100644
--- a/.github/workflows/ci-hobby.yml
+++ b/.github/workflows/ci-hobby.yml
@@ -21,7 +21,7 @@ concurrency:
 
 jobs:
     changes:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         # this is a slow one
         timeout-minutes: 30
         name: Setup DO Hobby Instance and test
diff --git a/.github/workflows/ci-hog.yml b/.github/workflows/ci-hog.yml
index 7fee499a801f1..ea51f70721f5c 100644
--- a/.github/workflows/ci-hog.yml
+++ b/.github/workflows/ci-hog.yml
@@ -20,7 +20,7 @@ jobs:
     # Job to decide if we should run backend ci
     # See https://github.com/dorny/paths-filter#conditional-execution for more details
     changes:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         name: Determine need to run Hog checks
         # Set job outputs to values from filter step
@@ -48,25 +48,23 @@ jobs:
     hog-tests:
         needs: changes
         timeout-minutes: 30
-
         name: Hog tests
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
+        if: needs.changes.outputs.hog == 'true'
 
         steps:
             # If this run wasn't initiated by the bot (meaning: snapshot update) and we've determined
             # there are backend changes, cancel previous runs
             - uses: n1hility/cancel-previous-runs@v3
-              if: github.actor != 'posthog-bot' && needs.changes.outputs.hog == 'true'
+              if: github.actor != 'posthog-bot'
               with:
                   token: ${{ secrets.GITHUB_TOKEN }}
 
             - uses: actions/checkout@v3
-              if: needs.changes.outputs.hog == 'true'
               with:
                   fetch-depth: 1
 
             - name: Set up Python
-              if: needs.changes.outputs.hog == 'true'
               uses: actions/setup-python@v5
               with:
                   python-version: 3.11.9
@@ -76,31 +74,25 @@ jobs:
 
             # uv is a fast pip alternative: https://github.com/astral-sh/uv/
             - run: pip install uv
-              if: needs.changes.outputs.hog == 'true'
 
             - name: Install SAML (python3-saml) dependencies
-              if: needs.changes.outputs.hog == 'true'
               run: |
                   sudo apt-get update
                   sudo apt-get install libxml2-dev libxmlsec1 libxmlsec1-dev libxmlsec1-openssl
 
             - name: Install Python dependencies
-              if: needs.changes.outputs.hog == 'true'
               run: |
                   uv pip install --system -r requirements.txt -r requirements-dev.txt
 
             - name: Install pnpm
-              if: needs.changes.outputs.hog == 'true'
               uses: pnpm/action-setup@v4
 
             - name: Set up Node.js
-              if: needs.changes.outputs.hog == 'true'
               uses: actions/setup-node@v4
               with:
-                  node-version: 18.12.1
+                  node-version: 18
 
             - name: Check if ANTLR definitions are up to date
-              if: needs.changes.outputs.hog == 'true'
               run: |
                   cd ..
                   sudo apt-get install default-jre
@@ -123,27 +115,175 @@ jobs:
                   ANTLR_VERSION: '4.13.2'
 
             - name: Check if STL bytecode is up to date
-              if: needs.changes.outputs.hog == 'true'
               run: |
                   python -m hogvm.stl.compile
                   git diff --exit-code
 
             - name: Run HogVM Python tests
-              if: needs.changes.outputs.hog == 'true'
               run: |
                   pytest hogvm
 
             - name: Run HogVM TypeScript tests
-              if: needs.changes.outputs.hog == 'true'
               run: |
                   cd hogvm/typescript
                   pnpm install --frozen-lockfile
                   pnpm run test
 
             - name: Run Hog tests
-              if: needs.changes.outputs.hog == 'true'
               run: |
                   cd hogvm/typescript
                   pnpm run build 
                   cd ../
                   ./test.sh && git diff --exit-code
+
+    check-package-version:
+        name: Check HogVM TypeScript package version and detect an update
+        needs: hog-tests
+        if: needs.hog-tests.result == 'success' && needs.changes.outputs.hog == 'true'
+        runs-on: ubuntu-24.04
+        outputs:
+            committed-version: ${{ steps.check-package-version.outputs.committed-version }}
+            published-version: ${{ steps.check-package-version.outputs.published-version }}
+            is-new-version: ${{ steps.check-package-version.outputs.is-new-version }}
+        steps:
+            - name: Checkout the repository
+              uses: actions/checkout@v2
+            - name: Check package version and detect an update
+              id: check-package-version
+              uses: PostHog/check-package-version@v2
+              with:
+                  path: hogvm/typescript
+
+    release-hogvm:
+        name: Release new HogVM TypeScript version
+        runs-on: ubuntu-24.04
+        needs: check-package-version
+        if: needs.changes.outputs.hog == 'true' && needs.check-package-version.outputs.is-new-version == 'true'
+        env:
+            COMMITTED_VERSION: ${{ needs.check-package-version.outputs.committed-version }}
+            PUBLISHED_VERSION: ${{ needs.check-package-version.outputs.published-version }}
+        steps:
+            - name: Checkout the repository
+              uses: actions/checkout@v4
+              with:
+                  fetch-depth: 1
+                  token: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN }}
+            - name: Set up Python
+              uses: actions/setup-python@v5
+              with:
+                  python-version: 3.11.9
+                  cache: 'pip'
+                  cache-dependency-path: '**/requirements*.txt'
+                  token: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN }}
+            - run: pip install uv
+            - name: Install SAML (python3-saml) dependencies
+              run: |
+                  sudo apt-get update
+                  sudo apt-get install libxml2-dev libxmlsec1 libxmlsec1-dev libxmlsec1-openssl
+            - name: Install Python dependencies
+              run: |
+                  uv pip install --system -r requirements.txt -r requirements-dev.txt
+            - name: Install pnpm
+              uses: pnpm/action-setup@v4
+            - name: Set up Node 18
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 18
+                  registry-url: https://registry.npmjs.org
+            - name: Install package.json dependencies
+              run: cd hogvm/typescript && pnpm install
+            - name: Publish the package in the npm registry
+              run: cd hogvm/typescript && npm publish --access public
+              env:
+                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+            - name: Sleep 60 seconds to allow npm to update the package
+              run: sleep 60
+
+    update-versions:
+        name: Update versions in package.json
+        runs-on: ubuntu-24.04
+        needs: release-hogvm
+        if: always() # This ensures the job runs regardless of the result of release-hogvm
+        steps:
+            - name: Checkout the repository
+              uses: actions/checkout@v4
+              with:
+                  fetch-depth: 1
+                  repository: ${{ github.event.pull_request.head.repo.full_name }}
+                  ref: ${{ github.event.pull_request.head.ref }}
+                  token: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN }}
+
+            - name: Install pnpm
+              uses: pnpm/action-setup@v4
+            - name: Set up Node 18
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 18
+                  registry-url: https://registry.npmjs.org
+
+            - name: Check for version mismatches
+              id: check-mismatch
+              run: |
+                  # Extract committed version
+                  HOGVM_VERSION=$(jq -r '.version' hogvm/typescript/package.json)
+
+                  # Compare dependencies in package.json
+                  MAIN_VERSION=$(jq -r '.dependencies."@posthog/hogvm"' package.json | tr -d '^')
+                  PLUGIN_VERSION=$(jq -r '.dependencies."@posthog/hogvm"' plugin-server/package.json | tr -d '^')
+
+                  echo "HOGVM_VERSION=$HOGVM_VERSION"
+                  echo "MAIN_VERSION=$MAIN_VERSION"
+                  echo "PLUGIN_VERSION=$PLUGIN_VERSION"
+
+                  # Set output if mismatches exist
+                  if [[ "$HOGVM_VERSION" != "$MAIN_VERSION" || "$HOGVM_VERSION" != "$PLUGIN_VERSION" ]]; then
+                      echo "mismatch=true" >> "$GITHUB_ENV"
+                  else
+                      echo "mismatch=false" >> "$GITHUB_ENV"
+                  fi
+
+            - name: Update package.json versions
+              if: env.mismatch == 'true'
+              run: |
+                  VERSION=$(jq ".version" hogvm/typescript/package.json -r)
+
+                  retry_pnpm_install() {
+                      local retries=0
+                      local max_retries=20 # 10 minutes total
+                      local delay=30
+
+                      while [[ $retries -lt $max_retries ]]; do
+                          echo "Attempting pnpm install (retry $((retries+1))/$max_retries)..."
+                          pnpm install --no-frozen-lockfile && break
+                          echo "Install failed. Retrying in $delay seconds..."
+                          sleep $delay
+                          retries=$((retries + 1))
+                      done
+
+                      if [[ $retries -eq $max_retries ]]; then
+                          echo "pnpm install failed after $max_retries attempts."
+                          exit 1
+                      fi
+                  }
+
+                  # Update main package.json
+                  mv package.json package.old.json
+                  jq --indent 4 '.dependencies."@posthog/hogvm" = "^'$VERSION'"' package.old.json > package.json
+                  rm package.old.json
+                  retry_pnpm_install
+
+                  # Update plugin-server/package.json
+                  cd plugin-server
+                  mv package.json package.old.json
+                  jq --indent 4 '.dependencies."@posthog/hogvm" = "^'$VERSION'"' package.old.json > package.json
+                  rm package.old.json
+                  retry_pnpm_install
+
+            - name: Commit updated package.json files
+              if: env.mismatch == 'true'
+              uses: EndBug/add-and-commit@v9
+              with:
+                  add: '["package.json", "pnpm-lock.yaml", "plugin-server/package.json", "plugin-server/pnpm-lock.yaml", "hogvm/typescript/package.json"]'
+                  message: 'Update @posthog/hogvm version in package.json'
+                  default_author: github_actions
+                  github_token: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN }}
diff --git a/.github/workflows/ci-plugin-server.yml b/.github/workflows/ci-plugin-server.yml
index ecd13c789ddf8..30ca845cd89b6 100644
--- a/.github/workflows/ci-plugin-server.yml
+++ b/.github/workflows/ci-plugin-server.yml
@@ -24,7 +24,7 @@ jobs:
     # Job to decide if we should run plugin server ci
     # See https://github.com/dorny/paths-filter#conditional-execution for more details
     changes:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         name: Determine need to run plugin server checks
         outputs:
@@ -53,7 +53,7 @@ jobs:
         name: Code quality
         needs: changes
         if: needs.changes.outputs.plugin-server == 'true'
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         defaults:
             run:
                 working-directory: 'plugin-server'
@@ -81,7 +81,7 @@ jobs:
     tests:
         name: Plugin Server Tests (${{matrix.shard}})
         needs: changes
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         strategy:
             fail-fast: false
@@ -193,7 +193,7 @@ jobs:
     functional-tests:
         name: Functional tests
         needs: changes
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         env:
             REDIS_URL: 'redis://localhost'
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index a914e2a95225e..56f1ed3bf0330 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -31,7 +31,7 @@ jobs:
         #   - https://gh.io/supported-runners-and-hardware-resources
         #   - https://gh.io/using-larger-runners (GitHub.com only)
         # Consider using larger runners or machines with greater resources for possible analysis time improvements.
-        runs-on: 'ubuntu-latest'
+        runs-on: 'ubuntu-24.04'
         timeout-minutes: 15
         permissions:
             # required for all workflows
diff --git a/.github/workflows/codespaces.yml b/.github/workflows/codespaces.yml
index b725c032ddacd..06f796951dbe2 100644
--- a/.github/workflows/codespaces.yml
+++ b/.github/workflows/codespaces.yml
@@ -21,7 +21,7 @@ on:
 jobs:
     build:
         name: Build Codespaces image
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         # Build on master and PRs with the label 'codespaces-build' only
         if: ${{ github.ref == 'refs/heads/master' || contains(github.event.pull_request.labels.*.name, 'codespaces-build')  }}
diff --git a/.github/workflows/container-images-cd.yml b/.github/workflows/container-images-cd.yml
index e7fe1a1608b73..b393214ec72da 100644
--- a/.github/workflows/container-images-cd.yml
+++ b/.github/workflows/container-images-cd.yml
@@ -22,7 +22,7 @@ jobs:
     posthog_build:
         name: Build and push PostHog
         if: github.repository == 'PostHog/posthog'
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         permissions:
             id-token: write # allow issuing OIDC tokens for this workflow run
             contents: read # allow at least reading the repo contents, add other permissions if necessary
diff --git a/.github/workflows/container-images-ci.yml b/.github/workflows/container-images-ci.yml
index c690c11dd2663..7b434a7cb546d 100644
--- a/.github/workflows/container-images-ci.yml
+++ b/.github/workflows/container-images-ci.yml
@@ -13,7 +13,7 @@ concurrency:
 jobs:
     posthog_build:
         name: Build Docker image
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         permissions:
             id-token: write # allow issuing OIDC tokens for this workflow run
             contents: read # allow at least reading the repo contents, add other permissions if necessary
@@ -51,7 +51,7 @@ jobs:
 
     lint:
         name: Lint changed Dockerfiles
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             - name: Check out
               uses: actions/checkout@v3
diff --git a/.github/workflows/copy-clickhouse-udfs.yml b/.github/workflows/copy-clickhouse-udfs.yml
index 3dc6fce3ade07..b55d66bc30e8b 100644
--- a/.github/workflows/copy-clickhouse-udfs.yml
+++ b/.github/workflows/copy-clickhouse-udfs.yml
@@ -9,7 +9,7 @@ on:
 
 jobs:
     trigger_udfs_workflow:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             - name: Trigger UDFs Workflow
               uses: benc-uk/workflow-dispatch@v1
diff --git a/.github/workflows/foss-sync.yml b/.github/workflows/foss-sync.yml
index 82334bfe89f5a..b8edfe63210b9 100644
--- a/.github/workflows/foss-sync.yml
+++ b/.github/workflows/foss-sync.yml
@@ -10,7 +10,7 @@ jobs:
     repo-sync:
         name: Sync posthog-foss with posthog
         if: github.repository == 'PostHog/posthog'
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             - name: Sync repositories 1 to 1 - master branch
               uses: PostHog/git-sync@v3
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 37c4e75ddb9bc..4fc7344a97216 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -7,7 +7,7 @@ on:
 
 jobs:
     test:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         steps:
             - name: Checkout code
diff --git a/.github/workflows/lint-pr.yml b/.github/workflows/lint-pr.yml
index 3efcc6c9523de..2f700829f2921 100644
--- a/.github/workflows/lint-pr.yml
+++ b/.github/workflows/lint-pr.yml
@@ -10,7 +10,7 @@ on:
 jobs:
     lint-pr:
         name: Validate PR title against Conventional Commits
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             - uses: amannn/action-semantic-pull-request@v5
               env:
diff --git a/.github/workflows/livestream-docker-image.yml b/.github/workflows/livestream-docker-image.yml
index 7023ee98c03f1..5efde377f5866 100644
--- a/.github/workflows/livestream-docker-image.yml
+++ b/.github/workflows/livestream-docker-image.yml
@@ -10,7 +10,7 @@ on:
 
 jobs:
     build:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         permissions:
             contents: read
@@ -59,7 +59,7 @@ jobs:
                   labels: ${{ steps.meta.outputs.labels }}
 
     deploy:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         needs: build
         steps:
             - name: get deployer token
diff --git a/.github/workflows/pr-cleanup.yml b/.github/workflows/pr-cleanup.yml
index 26f46533847f7..0c0586e8ec0b5 100644
--- a/.github/workflows/pr-cleanup.yml
+++ b/.github/workflows/pr-cleanup.yml
@@ -9,7 +9,7 @@ on:
 jobs:
     deploy_preview_cleanup:
         name: Deploy Preview Cleanup
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         if: ${{ contains(github.event.pull_request.labels.*.name, 'deploy') }}
 
         permissions:
diff --git a/.github/workflows/pr-deploy.yml b/.github/workflows/pr-deploy.yml
index 26896c7566091..807b1823dc17b 100644
--- a/.github/workflows/pr-deploy.yml
+++ b/.github/workflows/pr-deploy.yml
@@ -10,7 +10,7 @@ on:
 jobs:
     deploy_preview:
         name: Deploy preview environment
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
 
         permissions:
             id-token: write
diff --git a/.github/workflows/release-hogvm.yml b/.github/workflows/release-hogvm.yml
deleted file mode 100644
index 3d173bcca4591..0000000000000
--- a/.github/workflows/release-hogvm.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-name: 'Publish HogVM package'
-
-on:
-    push:
-        branches:
-            - main
-            - master
-
-jobs:
-    release:
-        name: Publish
-        runs-on: ubuntu-latest
-        defaults:
-            run:
-                working-directory: hogvm/typescript
-        steps:
-            - name: Checkout the repository
-              uses: actions/checkout@v4
-
-            - name: Check package version and detect an update
-              id: check-package-version
-              uses: PostHog/check-package-version@v2
-              with:
-                  path: hogvm/typescript
-
-            - name: Install pnpm
-              uses: pnpm/action-setup@v4
-
-            - name: Set up Node
-              uses: actions/setup-node@v4
-              if: steps.check-package-version.outputs.is-new-version == 'true'
-              with:
-                  node-version: 18.12.1
-                  registry-url: https://registry.npmjs.org
-                  cache: pnpm
-                  cache-dependency-path: hogvm/typescript/pnpm-lock.yaml
-
-            - name: Install dependencies
-              if: steps.check-package-version.outputs.is-new-version == 'true'
-              run: pnpm i --frozen-lockfile
-
-            - name: Build
-              if: steps.check-package-version.outputs.is-new-version == 'true'
-              run: pnpm build
-
-            - name: Publish the package in the npm registry
-              id: publish-package
-              if: steps.check-package-version.outputs.is-new-version == 'true'
-              run: |
-                  pnpm publish --access public --tag latest
-              env:
-                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
diff --git a/.github/workflows/rust-docker-build.yml b/.github/workflows/rust-docker-build.yml
index 1535867f572f0..4237599d9b311 100644
--- a/.github/workflows/rust-docker-build.yml
+++ b/.github/workflows/rust-docker-build.yml
@@ -118,7 +118,7 @@ jobs:
 
     deploy:
         name: deploy ${{ matrix.release }}
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         needs: build
         if: github.ref == 'refs/heads/master'
         strategy:
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 0dd62fcd25f7f..29268601c4db4 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -13,7 +13,7 @@ jobs:
     # Job to decide if we should run rust ci
     # See https://github.com/dorny/paths-filter#conditional-execution for more details
     changes:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         if: github.repository == 'PostHog/posthog'
         name: Determine need to run Rust checks
diff --git a/.github/workflows/stale.yaml b/.github/workflows/stale.yaml
index 9f2797cca668a..635e01600286c 100644
--- a/.github/workflows/stale.yaml
+++ b/.github/workflows/stale.yaml
@@ -7,7 +7,7 @@ jobs:
     stale:
         # Only unleash the stale bot on PostHog/posthog, as there's no POSTHOG_BOT_GITHUB_TOKEN token on forks
         if: ${{ github.repository == 'PostHog/posthog' }}
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         steps:
             - uses: actions/stale@v9
               with:
diff --git a/.github/workflows/storybook-chromatic.yml b/.github/workflows/storybook-chromatic.yml
index 809328e296c90..7d5d68e1ac2a3 100644
--- a/.github/workflows/storybook-chromatic.yml
+++ b/.github/workflows/storybook-chromatic.yml
@@ -18,7 +18,7 @@ concurrency:
 jobs:
     storybook-chromatic:
         name: Publish to Chromatic
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 15
         if: github.event.pull_request.head.repo.full_name == github.repository # Don't run on forks
         outputs:
@@ -50,7 +50,7 @@ jobs:
 
     visual-regression:
         name: Visual regression tests
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 30
         container:
             image: mcr.microsoft.com/playwright:v1.45.0
@@ -211,7 +211,7 @@ jobs:
 
     visual-regression-summary:
         name: Summarize visual regression tests
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         timeout-minutes: 5
         needs: visual-regression
         if: always() # Run even if visual-regression fails for one (or more) of the browsers
diff --git a/.github/workflows/storybook-deploy.yml b/.github/workflows/storybook-deploy.yml
index 9a04f8e582ced..33520a355a244 100644
--- a/.github/workflows/storybook-deploy.yml
+++ b/.github/workflows/storybook-deploy.yml
@@ -8,7 +8,7 @@ on:
 
 jobs:
     storybook-deployment:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         if: github.repository == 'PostHog/posthog'
         steps:
             - name: Check out PostHog/posthog repo
diff --git a/.github/workflows/vector-docker-build-deploy.yml b/.github/workflows/vector-docker-build-deploy.yml
index a1d97f846f298..d78e2e9b2d089 100644
--- a/.github/workflows/vector-docker-build-deploy.yml
+++ b/.github/workflows/vector-docker-build-deploy.yml
@@ -74,7 +74,7 @@ jobs:
                   platforms: linux/arm64,linux/amd64
 
     deploy:
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-24.04
         needs: build
         if: github.ref == 'refs/heads/master'
         steps:
diff --git a/.gitignore b/.gitignore
index a41dd0980a217..362ec30bce107 100644
--- a/.gitignore
+++ b/.gitignore
@@ -76,3 +76,4 @@ pyrightconfig.json
 .temporal-worker-settings
 temp_test_run_data.json
 .temp-deepeval-cache.json
+.eslintcache
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 3aa83e0bb4e0d..9eb3fe62780f2 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -106,6 +106,30 @@
                 "group": "main"
             }
         },
+        {
+            "name": "Celery Beat",
+            "consoleName": "Celery Beat",
+            "type": "debugpy",
+            "justMyCode": true,
+            "autoReload": {
+                "enable": true,
+                "include": ["posthog/**/*.py"]
+            },
+            "request": "launch",
+            "program": "${workspaceFolder}/manage.py",
+            "args": ["run_autoreload_celery", "--type=beat"],
+            "console": "integratedTerminal",
+            "cwd": "${workspaceFolder}",
+            "env": {
+                "SKIP_ASYNC_MIGRATIONS_SETUP": "1",
+                "DEBUG": "1",
+                "BILLING_SERVICE_URL": "https://billing.dev.posthog.dev",
+                "SKIP_SERVICE_VERSION_REQUIREMENTS": "1"
+            },
+            "presentation": {
+                "group": "main"
+            }
+        },
         {
             "name": "Plugin Server",
             "command": "npm run start:dev",
@@ -200,6 +224,27 @@
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen",
             "runtimeExecutable": "${env:HOME}/.nvm/versions/node/${input:pickVersion}/bin/node"
+        },
+        {
+            "name": "Python Debugger: Django Migrations",
+            "type": "debugpy",
+            "request": "launch",
+            "args": ["migrate", "posthog"],
+            "django": true,
+            "env": {
+                "PYTHONUNBUFFERED": "1",
+                "DJANGO_SETTINGS_MODULE": "posthog.settings",
+                "DEBUG": "1",
+                "CLICKHOUSE_SECURE": "False",
+                "KAFKA_HOSTS": "localhost",
+                "DATABASE_URL": "postgres://posthog:posthog@localhost:5432/posthog",
+                "SKIP_SERVICE_VERSION_REQUIREMENTS": "1",
+                "PRINT_SQL": "1",
+                "BILLING_SERVICE_URL": "http://localhost:8100/",
+                "CLOUD_DEPLOYMENT": "dev"
+            },
+            "autoStartBrowser": false,
+            "program": "${workspaceFolder}/manage.py"
         }
     ],
     "inputs": [
@@ -212,7 +257,14 @@
     "compounds": [
         {
             "name": "PostHog",
-            "configurations": ["Backend", "Celery Threaded Pool", "Frontend", "Plugin Server", "Temporal Worker"],
+            "configurations": [
+                "Backend",
+                "Celery Threaded Pool",
+                "Celery Beat",
+                "Frontend",
+                "Plugin Server",
+                "Temporal Worker"
+            ],
             "stopAll": true,
             "presentation": {
                 "order": 1,
diff --git a/bin/mprocs.yaml b/bin/mprocs.yaml
new file mode 100644
index 0000000000000..c7831d818d589
--- /dev/null
+++ b/bin/mprocs.yaml
@@ -0,0 +1,24 @@
+procs:
+    celery-worker:
+        shell: 'source ./bin/celery-queues.env && python manage.py run_autoreload_celery --type=worker'
+
+    celery-beat:
+        shell: 'source ./bin/celery-queues.env && python manage.py run_autoreload_celery --type=beat'
+
+    plugin-server:
+        shell: './bin/plugin-server'
+
+    backend:
+        shell: './bin/start-backend'
+
+    frontend:
+        shell: './bin/start-frontend'
+
+    temporal-worker:
+        # added a sleep to give the docker stuff time to start
+        shell: 'sleep 10 && python3 manage.py start_temporal_worker'
+
+    docker-compose:
+        shell: 'docker compose -f docker-compose.dev.yml up'
+        stop:
+            send-keys: ['<C-c>']
diff --git a/bin/start-mprocs b/bin/start-mprocs
new file mode 100755
index 0000000000000..ceaddede2140f
--- /dev/null
+++ b/bin/start-mprocs
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -e
+
+export DEBUG=${DEBUG:-1}
+export SKIP_SERVICE_VERSION_REQUIREMENTS=${SKIP_SERVICE_VERSION_REQUIREMENTS:-1}
+export BILLING_SERVICE_URL=${BILLING_SERVICE_URL:-https://billing.dev.posthog.dev}
+export HOG_HOOK_URL=${HOG_HOOK_URL:-http://localhost:3300/hoghook}
+
+[ ! -f ./share/GeoLite2-City.mmdb ] && ( curl -L "https://mmdbcdn.posthog.net/" --http1.1 | brotli --decompress --output=./share/GeoLite2-City.mmdb )
+
+exec mprocs --config bin/mprocs.yaml
diff --git a/cypress/README.md b/cypress/README.md
index 0930a0ad7bcbf..f043f6f0546b4 100644
--- a/cypress/README.md
+++ b/cypress/README.md
@@ -2,17 +2,13 @@
 
 The Cypress tests run with a PostHog instance that has no feature flags set up.
 
-To test feature flags you can intercept the call to the `decide` endpoint
+To test feature flags you can intercept the call to the `decide` endpoint using this helper
 
 ```javascript
 // sometimes the system under test calls `/decide`
 // and sometimes it calls https://app.posthog.com/decide
-cy.intercept('**/decide/*', (req) =>
-    req.reply(
-        decideResponse({
-            // add feature flags here, for e.g.
-            // 'feature-flag-key': true,
-        })
-    )
-)
+setupFeatureFlags({
+    // add feature flags here, for e.g.
+    'feature-flag-key': true,
+})
 ```
diff --git a/cypress/e2e/alerts.cy.ts b/cypress/e2e/alerts.cy.ts
index 82bd6bc10f4fb..91ecad1d24489 100644
--- a/cypress/e2e/alerts.cy.ts
+++ b/cypress/e2e/alerts.cy.ts
@@ -1,15 +1,11 @@
-import { decideResponse } from '../fixtures/api/decide'
 import { createInsight, createInsightWithBreakdown } from '../productAnalytics'
+import { setupFeatureFlags } from '../support/decide'
 
 describe('Alerts', () => {
     beforeEach(() => {
-        cy.intercept('**/decide/*', (req) =>
-            req.reply(
-                decideResponse({
-                    alerts: true,
-                })
-            )
-        )
+        setupFeatureFlags({
+            alerts: true,
+        })
         createInsight('insight')
     })
 
diff --git a/cypress/e2e/dashboard.cy.ts b/cypress/e2e/dashboard.cy.ts
index b5f62097ebee1..cefbb60b6fe69 100644
--- a/cypress/e2e/dashboard.cy.ts
+++ b/cypress/e2e/dashboard.cy.ts
@@ -379,6 +379,8 @@ describe('Dashboard', () => {
         cy.get('[data-attr="date-filter"]').click()
         cy.contains('span', 'Last 14 days').click()
 
+        cy.wait(2000)
+
         // insight meta should be updated to show new date range
         cy.get('h5').contains('Last 14 days').should('exist')
 
diff --git a/cypress/e2e/experiments.cy.ts b/cypress/e2e/experiments.cy.ts
index 5a7d92c3f49c1..a635cf7841cad 100644
--- a/cypress/e2e/experiments.cy.ts
+++ b/cypress/e2e/experiments.cy.ts
@@ -1,4 +1,4 @@
-import { decideResponse } from '../fixtures/api/decide'
+import { setupFeatureFlags } from '../support/decide'
 
 describe('Experiments', () => {
     let randomNum
@@ -47,13 +47,10 @@ describe('Experiments', () => {
     })
 
     const createExperimentInNewUi = (): void => {
-        cy.intercept('**/decide/*', (req) =>
-            req.reply(
-                decideResponse({
-                    'new-experiments-ui': true,
-                })
-            )
-        )
+        setupFeatureFlags({
+            'new-experiments-ui': true,
+        })
+
         cy.visit('/experiments')
 
         // Name, flag key, description
diff --git a/cypress/e2e/exports.cy.ts b/cypress/e2e/exports.cy.ts
index 7e96b0c56d454..8131a98425602 100644
--- a/cypress/e2e/exports.cy.ts
+++ b/cypress/e2e/exports.cy.ts
@@ -1,18 +1,14 @@
 import { urls } from 'scenes/urls'
 
-import { decideResponse } from '../fixtures/api/decide'
+import { setupFeatureFlags } from '../support/decide'
 
 // NOTE: As the API data is randomly generated, we are only really testing here that the overall output is correct
 // The actual graph is not under test
 describe('Exporting Insights', () => {
     beforeEach(() => {
-        cy.intercept('https://us.i.posthog.com/decide/*', (req) =>
-            req.reply(
-                decideResponse({
-                    'export-dashboard-insights': true,
-                })
-            )
-        )
+        setupFeatureFlags({
+            'export-dashboard-insights': true,
+        })
         cy.visit(urls.insightNew())
         // apply filter
         cy.get('[data-attr$=add-filter-group]').click()
diff --git a/cypress/e2e/featureFlags.cy.ts b/cypress/e2e/featureFlags.cy.ts
index 2dceb97af6b21..df4d740b8ec4b 100644
--- a/cypress/e2e/featureFlags.cy.ts
+++ b/cypress/e2e/featureFlags.cy.ts
@@ -1,10 +1,10 @@
-import { decideResponse } from '../fixtures/api/decide'
+import { setupFeatureFlags } from '../support/decide'
 
 describe('Feature Flags', () => {
     let name
 
     beforeEach(() => {
-        cy.intercept('**/decide/*', (req) => req.reply(decideResponse({})))
+        setupFeatureFlags({})
 
         cy.intercept('/api/projects/*/property_definitions?type=person*', {
             fixture: 'api/feature-flags/property_definition',
diff --git a/cypress/e2e/insights-navigation-open-sql-insight-first.cy.ts b/cypress/e2e/insights-navigation-open-sql-insight-first.cy.ts
index 85f472a09c97b..a902e861bacd6 100644
--- a/cypress/e2e/insights-navigation-open-sql-insight-first.cy.ts
+++ b/cypress/e2e/insights-navigation-open-sql-insight-first.cy.ts
@@ -56,6 +56,9 @@ describe('Insights', () => {
 
             it('can open a new stickiness insight', () => {
                 insight.clickTab('STICKINESS')
+                // this test flaps, so check for a parent element, that is present even when failing
+                // in the hope that it slows the test down a little and stops it flapping
+                cy.get('.InsightVizDisplay--type-stickiness').should('exist')
                 cy.get('.TrendsInsight canvas').should('exist')
             })
 
diff --git a/cypress/e2e/onboarding.cy.ts b/cypress/e2e/onboarding.cy.ts
index b9453689a12aa..3ffd5ccc4bc27 100644
--- a/cypress/e2e/onboarding.cy.ts
+++ b/cypress/e2e/onboarding.cy.ts
@@ -1,16 +1,11 @@
-import { decideResponse } from '../fixtures/api/decide'
+import { setupFeatureFlags } from '../support/decide'
 
 describe('Onboarding', () => {
     beforeEach(() => {
         cy.intercept('/api/billing/', { fixture: 'api/billing/billing-unsubscribed.json' })
-
-        cy.intercept('**/decide/*', (req) =>
-            req.reply(
-                decideResponse({
-                    'product-intro-pages': 'test',
-                })
-            )
-        )
+        setupFeatureFlags({
+            'product-intro-pages': 'test',
+        })
     })
 
     it('Navigate between /products to /onboarding to a product intro page', () => {
diff --git a/cypress/e2e/signup.cy.ts b/cypress/e2e/signup.cy.ts
index 9774236ef81c4..76d7a694d8c50 100644
--- a/cypress/e2e/signup.cy.ts
+++ b/cypress/e2e/signup.cy.ts
@@ -1,4 +1,4 @@
-import { decideResponse } from '../fixtures/api/decide'
+import { setupFeatureFlags } from '../support/decide'
 
 const VALID_PASSWORD = 'hedgE-hog-123%'
 
@@ -171,13 +171,9 @@ describe('Signup', () => {
     })
 
     it('Shows redirect notice if redirecting for maintenance', () => {
-        cy.intercept('**/decide/*', (req) =>
-            req.reply(
-                decideResponse({
-                    'redirect-signups-to-instance': 'us',
-                })
-            )
-        )
+        setupFeatureFlags({
+            'redirect-signups-to-instance': 'us',
+        })
 
         cy.visit('/logout')
         cy.location('pathname').should('include', '/login')
diff --git a/cypress/fixtures/api/decide.js b/cypress/fixtures/api/decide.js
index 102f1211152c1..7c03b11c6dc48 100644
--- a/cypress/fixtures/api/decide.js
+++ b/cypress/fixtures/api/decide.js
@@ -8,6 +8,7 @@ export function decideResponse(featureFlags) {
         },
         isAuthenticated: true,
         supportedCompression: ['gzip', 'gzip-js', 'lz64'],
+        hasFeatureFlags: Object.keys(featureFlags).length > 0,
         featureFlags,
         sessionRecording: {
             endpoint: '/s/',
diff --git a/cypress/support/decide.ts b/cypress/support/decide.ts
new file mode 100644
index 0000000000000..a32e192f74d25
--- /dev/null
+++ b/cypress/support/decide.ts
@@ -0,0 +1,28 @@
+import { decideResponse } from '../fixtures/api/decide'
+
+export const setupFeatureFlags = (overrides: Record<string, any> = {}): void => {
+    // Tricky - the new RemoteConfig endpoint is optimised to not load decide if there are no feature flags in the DB.
+    // We need to intercept both the RemoteConfig and the decide endpoint to ensure that the feature flags are always loaded.
+
+    cy.intercept('**/array/*/config', (req) =>
+        req.reply(
+            decideResponse({
+                ...overrides,
+            })
+        )
+    )
+
+    cy.intercept('**/array/*/config.js', (req) =>
+        req.continue((res) => {
+            res.send(res.body)
+        })
+    )
+
+    cy.intercept('**/decide/*', (req) =>
+        req.reply(
+            decideResponse({
+                ...overrides,
+            })
+        )
+    )
+}
diff --git a/cypress/support/e2e.ts b/cypress/support/e2e.ts
index fe164bf074b3a..f05a549c9bf30 100644
--- a/cypress/support/e2e.ts
+++ b/cypress/support/e2e.ts
@@ -4,7 +4,7 @@ import 'cypress-axe'
 
 import { urls } from 'scenes/urls'
 
-import { decideResponse } from '../fixtures/api/decide'
+import { setupFeatureFlags } from './decide'
 
 try {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -86,14 +86,7 @@ beforeEach(() => {
     Cypress.env('POSTHOG_PROPERTY_GITHUB_ACTION_RUN_URL', process.env.GITHUB_ACTION_RUN_URL)
     cy.useSubscriptionStatus('subscribed')
 
-    cy.intercept('**/decide/*', (req) =>
-        req.reply(
-            decideResponse({
-                // Feature flag to be treated as rolled out in E2E tests, e.g.:
-                // 'toolbar-launch-side-action': true,
-            })
-        )
-    )
+    setupFeatureFlags({})
 
     // un-intercepted sometimes this doesn't work and the page gets stuck on the SpinnerOverlay
     cy.intercept(/app.posthog.com\/api\/projects\/@current\/feature_flags\/my_flags.*/, (req) => req.reply([]))
diff --git a/ee/api/billing.py b/ee/api/billing.py
index 7fe7e4942b586..7d717ca740510 100644
--- a/ee/api/billing.py
+++ b/ee/api/billing.py
@@ -62,7 +62,10 @@ def list(self, request: Request, *args: Any, **kwargs: Any) -> Response:
 
         plan_keys = request.query_params.get("plan_keys", None)
         billing_manager = self.get_billing_manager()
-        response = billing_manager.get_billing(org, plan_keys)
+        query = {}
+        if "include_forecasting" in request.query_params:
+            query["include_forecasting"] = request.query_params.get("include_forecasting")
+        response = billing_manager.get_billing(org, plan_keys, query)
 
         return Response(response)
 
diff --git a/ee/api/conversation.py b/ee/api/conversation.py
new file mode 100644
index 0000000000000..70e314b94039f
--- /dev/null
+++ b/ee/api/conversation.py
@@ -0,0 +1,69 @@
+from typing import cast
+
+from django.http import StreamingHttpResponse
+from pydantic import ValidationError
+from rest_framework import serializers
+from rest_framework.renderers import BaseRenderer
+from rest_framework.request import Request
+from rest_framework.viewsets import GenericViewSet
+
+from ee.hogai.assistant import Assistant
+from ee.models.assistant import Conversation
+from posthog.api.routing import TeamAndOrgViewSetMixin
+from posthog.models.user import User
+from posthog.rate_limit import AIBurstRateThrottle, AISustainedRateThrottle
+from posthog.schema import HumanMessage
+
+
+class MessageSerializer(serializers.Serializer):
+    content = serializers.CharField(required=True, max_length=1000)
+    conversation = serializers.UUIDField(required=False)
+
+    def validate(self, data):
+        try:
+            message = HumanMessage(content=data["content"])
+            data["message"] = message
+        except ValidationError:
+            raise serializers.ValidationError("Invalid message content.")
+        return data
+
+
+class ServerSentEventRenderer(BaseRenderer):
+    media_type = "text/event-stream"
+    format = "txt"
+
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        return data
+
+
+class ConversationViewSet(TeamAndOrgViewSetMixin, GenericViewSet):
+    scope_object = "INTERNAL"
+    serializer_class = MessageSerializer
+    renderer_classes = [ServerSentEventRenderer]
+    queryset = Conversation.objects.all()
+    lookup_url_kwarg = "conversation"
+
+    def safely_get_queryset(self, queryset):
+        # Only allow access to conversations created by the current user
+        return queryset.filter(user=self.request.user)
+
+    def get_throttles(self):
+        return [AIBurstRateThrottle(), AISustainedRateThrottle()]
+
+    def create(self, request: Request, *args, **kwargs):
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        conversation_id = serializer.validated_data.get("conversation")
+        if conversation_id:
+            self.kwargs[self.lookup_url_kwarg] = conversation_id
+            conversation = self.get_object()
+        else:
+            conversation = self.get_queryset().create(user=request.user, team=self.team)
+        assistant = Assistant(
+            self.team,
+            conversation,
+            serializer.validated_data["message"],
+            user=cast(User, request.user),
+            is_new_conversation=not conversation_id,
+        )
+        return StreamingHttpResponse(assistant.stream(), content_type=ServerSentEventRenderer.media_type)
diff --git a/ee/api/dashboard_collaborator.py b/ee/api/dashboard_collaborator.py
index 1687bf5d83115..4cdd8833983cd 100644
--- a/ee/api/dashboard_collaborator.py
+++ b/ee/api/dashboard_collaborator.py
@@ -91,7 +91,7 @@ class DashboardCollaboratorViewSet(
     scope_object = "dashboard"
     permission_classes = [CanEditDashboardCollaborator]
     pagination_class = None
-    queryset = DashboardPrivilege.objects.select_related("dashboard").filter(user__is_active=True)
+    queryset = DashboardPrivilege.objects.select_related("dashboard", "dashboard__team").filter(user__is_active=True)
     lookup_field = "user__uuid"
     serializer_class = DashboardCollaboratorSerializer
     filter_rewrite_rules = {"project_id": "dashboard__team__project_id"}
diff --git a/ee/api/ee_event_definition.py b/ee/api/ee_event_definition.py
index 325a845aaa804..2c36958e505c7 100644
--- a/ee/api/ee_event_definition.py
+++ b/ee/api/ee_event_definition.py
@@ -11,6 +11,10 @@
 )
 
 from loginas.utils import is_impersonated_session
+from typing import cast
+import posthoganalytics
+from posthog.event_usage import groups
+from posthog.models import User
 
 
 class EnterpriseEventDefinitionSerializer(TaggedItemSerializerMixin, serializers.ModelSerializer):
@@ -104,6 +108,23 @@ def update(self, event_definition: EnterpriseEventDefinition, validated_data):
             detail=Detail(name=str(event_definition.name), changes=changes),
         )
 
+        verified_old = event_definition.verified
+        verified_new = validated_data.get("verified", verified_old)
+
+        # If verified status has changed, track it
+        if "verified" in validated_data and verified_old != verified_new:
+            user = cast(User, self.context["request"].user)
+            posthoganalytics.capture(
+                str(user.distinct_id),
+                "event verification toggled",
+                properties={
+                    "verified": verified_new,
+                    "event_name": event_definition.name,
+                    "is_custom_event": not event_definition.name.startswith("$"),
+                },
+                groups=groups(user.organization),
+            )
+
         return super().update(event_definition, validated_data)
 
     def to_representation(self, instance):
diff --git a/ee/api/hooks.py b/ee/api/hooks.py
index 6dd6dfd85e5c3..22d54c4b7bf8e 100644
--- a/ee/api/hooks.py
+++ b/ee/api/hooks.py
@@ -23,6 +23,7 @@ def create_zapier_hog_function(hook: Hook, serializer_context: dict) -> HogFunct
     serializer = HogFunctionSerializer(
         data={
             "template_id": template_zapier.id,
+            "type": "destination",
             "name": f"Zapier webhook for action {hook.resource_id}",
             "filters": {"actions": [{"id": str(hook.resource_id), "name": "", "type": "actions", "order": 0}]},
             "inputs": {
diff --git a/ee/api/test/test_billing.py b/ee/api/test/test_billing.py
index 2875145441d69..d2afa2bc46569 100644
--- a/ee/api/test/test_billing.py
+++ b/ee/api/test/test_billing.py
@@ -840,6 +840,37 @@ def mock_implementation(url: str, headers: Any = None, params: Any = None) -> Ma
 
         assert self.organization.customer_trust_scores == {"recordings": 0, "events": 15, "rows_synced": 0}
 
+    @patch("ee.api.billing.requests.get")
+    def test_billing_with_supported_params(self, mock_get):
+        """Test that the include_forecasting param is passed through to the billing service."""
+
+        def mock_implementation(url: str, headers: Any = None, params: Any = None) -> MagicMock:
+            mock = MagicMock()
+            mock.status_code = 200
+
+            if "api/billing/portal" in url:
+                mock.json.return_value = {"url": "https://billing.stripe.com/p/session/test_1234"}
+            elif "api/billing" in url:
+                mock.json.return_value = create_billing_response(
+                    customer=create_billing_customer(has_active_subscription=True)
+                )
+
+            return mock
+
+        mock_get.side_effect = mock_implementation
+
+        response = self.client.get("/api/billing/?include_forecasting=true")
+        assert response.status_code == 200
+
+        # Verify the billing service was called with the correct query param
+        billing_calls = [
+            call
+            for call in mock_get.call_args_list
+            if "api/billing" in call[0][0] and "api/billing/portal" not in call[0][0]
+        ]
+        assert len(billing_calls) == 1
+        assert billing_calls[0].kwargs["params"] == {"include_forecasting": "true"}
+
 
 class TestPortalBillingAPI(APILicensedTest):
     @patch("ee.api.billing.requests.get")
@@ -932,7 +963,7 @@ def test_deactivate_success(self, mock_get_billing, mock_deactivate_products):
 
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         mock_deactivate_products.assert_called_once_with(self.organization, "product_1")
-        mock_get_billing.assert_called_once_with(self.organization, None)
+        mock_get_billing.assert_called_once_with(self.organization, None, {})
 
     def test_deactivate_failure(self):
         url = "/api/billing/deactivate"
diff --git a/ee/api/test/test_conversation.py b/ee/api/test/test_conversation.py
new file mode 100644
index 0000000000000..6eb466876dc01
--- /dev/null
+++ b/ee/api/test/test_conversation.py
@@ -0,0 +1,157 @@
+from unittest.mock import patch
+
+from rest_framework import status
+
+from ee.hogai.assistant import Assistant
+from ee.models.assistant import Conversation
+from posthog.models.team.team import Team
+from posthog.models.user import User
+from posthog.test.base import APIBaseTest
+
+
+class TestConversation(APIBaseTest):
+    def setUp(self):
+        super().setUp()
+        self.other_team = Team.objects.create(organization=self.organization, name="other team")
+        self.other_user = User.objects.create_and_join(
+            organization=self.organization,
+            email="other@posthog.com",
+            password="password",
+            first_name="Other",
+        )
+
+    def _get_streaming_content(self, response):
+        return b"".join(response.streaming_content)
+
+    def test_create_conversation(self):
+        with patch.object(Assistant, "_stream", return_value=["test response"]) as stream_mock:
+            response = self.client.post(
+                f"/api/environments/{self.team.id}/conversations/",
+                {"content": "test query"},
+            )
+            self.assertEqual(response.status_code, status.HTTP_200_OK)
+            self.assertEqual(self._get_streaming_content(response), b"test response")
+            self.assertEqual(Conversation.objects.count(), 1)
+            conversation: Conversation = Conversation.objects.first()
+            self.assertEqual(conversation.user, self.user)
+            self.assertEqual(conversation.team, self.team)
+            stream_mock.assert_called_once()
+
+    def test_add_message_to_existing_conversation(self):
+        with patch.object(Assistant, "_stream", return_value=["test response"]) as stream_mock:
+            conversation = Conversation.objects.create(user=self.user, team=self.team)
+            response = self.client.post(
+                f"/api/environments/{self.team.id}/conversations/",
+                {
+                    "conversation": str(conversation.id),
+                    "content": "test query",
+                },
+            )
+            self.assertEqual(response.status_code, status.HTTP_200_OK)
+            self.assertEqual(self._get_streaming_content(response), b"test response")
+            self.assertEqual(Conversation.objects.count(), 1)
+            stream_mock.assert_called_once()
+
+    def test_cant_access_other_users_conversation(self):
+        conversation = Conversation.objects.create(user=self.other_user, team=self.team)
+
+        self.client.force_login(self.user)
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {"conversation": conversation.id, "content": "test query"},
+        )
+
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+    def test_cant_access_other_teams_conversation(self):
+        conversation = Conversation.objects.create(user=self.user, team=self.other_team)
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {"conversation": conversation.id, "content": "test query"},
+        )
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+    def test_invalid_message_format(self):
+        response = self.client.post("/api/environments/@current/conversations/")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_rate_limit_burst(self):
+        # Create multiple requests to trigger burst rate limit
+        with patch.object(Assistant, "_stream", return_value=["test response"]):
+            for _ in range(11):  # Assuming burst limit is less than this
+                response = self.client.post(
+                    f"/api/environments/{self.team.id}/conversations/",
+                    {"content": "test query"},
+                )
+            self.assertEqual(response.status_code, status.HTTP_429_TOO_MANY_REQUESTS)
+
+    def test_empty_content(self):
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {"content": ""},
+        )
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_content_too_long(self):
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {"content": "x" * 1001},  # Very long message
+        )
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_invalid_conversation_id(self):
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {
+                "conversation": "not-a-valid-uuid",
+                "content": "test query",
+            },
+        )
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_nonexistent_conversation(self):
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {
+                "conversation": "12345678-1234-5678-1234-567812345678",
+                "content": "test query",
+            },
+        )
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+    def test_deleted_conversation(self):
+        # Create and then delete a conversation
+        conversation = Conversation.objects.create(user=self.user, team=self.team)
+        conversation_id = conversation.id
+        conversation.delete()
+
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {
+                "conversation": str(conversation_id),
+                "content": "test query",
+            },
+        )
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+    def test_unauthenticated_request(self):
+        self.client.logout()
+        response = self.client.post(
+            f"/api/environments/{self.team.id}/conversations/",
+            {"content": "test query"},
+        )
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+
+    def test_streaming_error_handling(self):
+        def raise_error():
+            yield "some content"
+            raise Exception("Streaming error")
+
+        with patch.object(Assistant, "_stream", side_effect=raise_error):
+            response = self.client.post(
+                f"/api/environments/{self.team.id}/conversations/",
+                {"content": "test query"},
+            )
+            with self.assertRaises(Exception) as context:
+                b"".join(response.streaming_content)
+            self.assertTrue("Streaming error" in str(context.exception))
diff --git a/ee/benchmarks/benchmarks.py b/ee/benchmarks/benchmarks.py
index 1784cae10a402..645c04a72f00a 100644
--- a/ee/benchmarks/benchmarks.py
+++ b/ee/benchmarks/benchmarks.py
@@ -4,9 +4,9 @@
 from datetime import timedelta
 from ee.clickhouse.materialized_columns.analyze import (
     backfill_materialized_columns,
-    get_materialized_columns,
     materialize,
 )
+from ee.clickhouse.materialized_columns.columns import MaterializedColumn
 from ee.clickhouse.queries.stickiness import ClickhouseStickiness
 from ee.clickhouse.queries.funnels.funnel_correlation import FunnelCorrelation
 from posthog.queries.funnels import ClickhouseFunnel
@@ -771,15 +771,17 @@ def track_person_property_values_materialized(self):
 
     def setup(self):
         for table, properties in MATERIALIZED_PROPERTIES.items():
-            existing_materialized_columns = get_materialized_columns(table)
-            for property in properties:
-                if (property, "properties") not in existing_materialized_columns:
-                    materialize(table, property)
-                    backfill_materialized_columns(
-                        table,
-                        [(property, "properties")],
-                        backfill_period=timedelta(days=1_000),
-                    )
+            columns = [
+                materialize(table, property)
+                for property in (
+                    set(properties) - {column.details.property_name for column in MaterializedColumn.get_all(table)}
+                )
+            ]
+            backfill_materialized_columns(
+                table,
+                columns,
+                backfill_period=timedelta(days=1_000),
+            )
 
         # :TRICKY: Data in benchmark servers has ID=2
         team = Team.objects.filter(id=2).first()
diff --git a/ee/benchmarks/helpers.py b/ee/benchmarks/helpers.py
index 285a1dc97ee9f..8535e6adef47d 100644
--- a/ee/benchmarks/helpers.py
+++ b/ee/benchmarks/helpers.py
@@ -14,7 +14,7 @@
 
 django.setup()
 
-from posthog.clickhouse.materialized_columns import get_enabled_materialized_columns  # noqa: E402
+from ee.clickhouse.materialized_columns.columns import get_enabled_materialized_columns  # noqa: E402
 from posthog import client  # noqa: E402
 from posthog.clickhouse.query_tagging import reset_query_tags, tag_queries  # noqa: E402
 from posthog.models.utils import UUIDT  # noqa: E402
diff --git a/ee/billing/billing_manager.py b/ee/billing/billing_manager.py
index 5363053487c9e..ea033a4e0a9e0 100644
--- a/ee/billing/billing_manager.py
+++ b/ee/billing/billing_manager.py
@@ -74,9 +74,14 @@ def __init__(self, license, user: Optional[User] = None):
         self.license = license or get_cached_instance_license()
         self.user = user
 
-    def get_billing(self, organization: Optional[Organization], plan_keys: Optional[str]) -> dict[str, Any]:
+    def get_billing(
+        self,
+        organization: Optional[Organization],
+        plan_keys: Optional[str],
+        query_params: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
         if organization and self.license and self.license.is_v2_license:
-            billing_service_response = self._get_billing(organization)
+            billing_service_response = self._get_billing(organization, query_params)
 
             # Ensure the license and org are updated with the latest info
             if billing_service_response.get("license"):
@@ -225,7 +230,7 @@ def update_license_details(self, billing_status: BillingStatus) -> License:
 
         return self.license
 
-    def _get_billing(self, organization: Organization) -> BillingStatus:
+    def _get_billing(self, organization: Organization, query_params: Optional[dict[str, Any]] = None) -> BillingStatus:
         """
         Retrieves billing info and updates local models if necessary
         """
@@ -235,6 +240,7 @@ def _get_billing(self, organization: Organization) -> BillingStatus:
         res = requests.get(
             f"{BILLING_SERVICE_URL}/api/billing",
             headers=self.get_auth_headers(organization),
+            params=query_params,
         )
         handle_billing_service_error(res)
 
diff --git a/ee/clickhouse/materialized_columns/analyze.py b/ee/clickhouse/materialized_columns/analyze.py
index 43a1e83256912..fd1d1d09cb159 100644
--- a/ee/clickhouse/materialized_columns/analyze.py
+++ b/ee/clickhouse/materialized_columns/analyze.py
@@ -8,6 +8,7 @@
 
 from ee.clickhouse.materialized_columns.columns import (
     DEFAULT_TABLE_COLUMN,
+    MaterializedColumn,
     backfill_materialized_columns,
     get_materialized_columns,
     materialize,
@@ -28,6 +29,7 @@
 from posthog.models.property import PropertyName, TableColumn, TableWithProperties
 from posthog.models.property_definition import PropertyDefinition
 from posthog.models.team import Team
+from posthog.settings import CLICKHOUSE_CLUSTER
 
 Suggestion = tuple[TableWithProperties, TableColumn, PropertyName]
 
@@ -129,7 +131,7 @@ def _analyze(since_hours_ago: int, min_query_time: int, team_id: Optional[int] =
     --formatReadableSize(avg(read_bytes)),
     --formatReadableSize(max(read_bytes))
 FROM
-    clusterAllReplicas(posthog, system, query_log)
+    clusterAllReplicas({cluster}, system, query_log)
 WHERE
     query_start_time > now() - toIntervalHour({since})
     and query LIKE '%JSONExtract%'
@@ -157,6 +159,7 @@ def _analyze(since_hours_ago: int, min_query_time: int, team_id: Optional[int] =
             since=since_hours_ago,
             min_query_time=min_query_time,
             team_id_filter=f"and JSONExtractInt(log_comment, 'team_id') = {team_id}" if team_id else "",
+            cluster=CLICKHOUSE_CLUSTER,
         ),
     )
 
@@ -164,30 +167,31 @@ def _analyze(since_hours_ago: int, min_query_time: int, team_id: Optional[int] =
 
 
 def materialize_properties_task(
-    columns_to_materialize: Optional[list[Suggestion]] = None,
+    properties_to_materialize: Optional[list[Suggestion]] = None,
     time_to_analyze_hours: int = MATERIALIZE_COLUMNS_ANALYSIS_PERIOD_HOURS,
     maximum: int = MATERIALIZE_COLUMNS_MAX_AT_ONCE,
     min_query_time: int = MATERIALIZE_COLUMNS_MINIMUM_QUERY_TIME,
     backfill_period_days: int = MATERIALIZE_COLUMNS_BACKFILL_PERIOD_DAYS,
     dry_run: bool = False,
     team_id_to_analyze: Optional[int] = None,
+    is_nullable: bool = False,
 ) -> None:
     """
     Creates materialized columns for event and person properties based off of slow queries
     """
 
-    if columns_to_materialize is None:
-        columns_to_materialize = _analyze(time_to_analyze_hours, min_query_time, team_id_to_analyze)
+    if properties_to_materialize is None:
+        properties_to_materialize = _analyze(time_to_analyze_hours, min_query_time, team_id_to_analyze)
 
-    columns_by_table: dict[TableWithProperties, list[tuple[TableColumn, PropertyName]]] = defaultdict(list)
-    for table, table_column, property_name in columns_to_materialize:
-        columns_by_table[table].append((table_column, property_name))
+    properties_by_table: dict[TableWithProperties, list[tuple[TableColumn, PropertyName]]] = defaultdict(list)
+    for table, table_column, property_name in properties_to_materialize:
+        properties_by_table[table].append((table_column, property_name))
 
     result: list[Suggestion] = []
-    for table, columns in columns_by_table.items():
-        existing_materialized_columns = get_materialized_columns(table)
-        for table_column, property_name in columns:
-            if (property_name, table_column) not in existing_materialized_columns:
+    for table, properties in properties_by_table.items():
+        existing_materialized_properties = get_materialized_columns(table).keys()
+        for table_column, property_name in properties:
+            if (property_name, table_column) not in existing_materialized_properties:
                 result.append((table, table_column, property_name))
 
     if len(result) > 0:
@@ -195,18 +199,15 @@ def materialize_properties_task(
     else:
         logger.info("Found no columns to materialize.")
 
-    properties: dict[TableWithProperties, list[tuple[PropertyName, TableColumn]]] = {
-        "events": [],
-        "person": [],
-    }
+    materialized_columns: dict[TableWithProperties, list[MaterializedColumn]] = defaultdict(list)
     for table, table_column, property_name in result[:maximum]:
         logger.info(f"Materializing column. table={table}, property_name={property_name}")
-
         if not dry_run:
-            materialize(table, property_name, table_column=table_column)
-        properties[table].append((property_name, table_column))
+            materialized_columns[table].append(
+                materialize(table, property_name, table_column=table_column, is_nullable=is_nullable)
+            )
 
     if backfill_period_days > 0 and not dry_run:
         logger.info(f"Starting backfill for new materialized columns. period_days={backfill_period_days}")
-        backfill_materialized_columns("events", properties["events"], timedelta(days=backfill_period_days))
-        backfill_materialized_columns("person", properties["person"], timedelta(days=backfill_period_days))
+        for table, columns in materialized_columns.items():
+            backfill_materialized_columns(table, columns, timedelta(days=backfill_period_days))
diff --git a/ee/clickhouse/materialized_columns/columns.py b/ee/clickhouse/materialized_columns/columns.py
index c9624bf96bacd..ab051fee55e40 100644
--- a/ee/clickhouse/materialized_columns/columns.py
+++ b/ee/clickhouse/materialized_columns/columns.py
@@ -1,33 +1,35 @@
 from __future__ import annotations
 
+import logging
 import re
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterable, Iterator
 from copy import copy
 from dataclasses import dataclass, replace
 from datetime import timedelta
-from typing import Any, Literal, NamedTuple, TypeVar, cast
+from typing import Any, Literal, TypeVar, cast
 
 from clickhouse_driver import Client
 from django.utils.timezone import now
 
+from posthog.cache_utils import cache_for
 from posthog.clickhouse.client.connection import default_client
 from posthog.clickhouse.cluster import ClickhouseCluster, ConnectionInfo, FuturesMap, HostInfo
 from posthog.clickhouse.kafka_engine import trim_quotes_expr
 from posthog.clickhouse.materialized_columns import ColumnName, TablesWithMaterializedColumns
 from posthog.client import sync_execute
 from posthog.models.event.sql import EVENTS_DATA_TABLE
-from posthog.models.instance_setting import get_instance_setting
 from posthog.models.person.sql import PERSONS_TABLE
 from posthog.models.property import PropertyName, TableColumn, TableWithProperties
 from posthog.models.utils import generate_random_short_suffix
 from posthog.settings import CLICKHOUSE_DATABASE, CLICKHOUSE_PER_TEAM_SETTINGS, TEST
 
+
+logger = logging.getLogger(__name__)
+
 T = TypeVar("T")
 
 DEFAULT_TABLE_COLUMN: Literal["properties"] = "properties"
 
-TRIM_AND_EXTRACT_PROPERTY = trim_quotes_expr("JSONExtractRaw({table_column}, %(property)s)")
-
 SHORT_TABLE_COLUMN_NAME = {
     "properties": "p",
     "group_properties": "gp",
@@ -40,15 +42,36 @@
 }
 
 
-class MaterializedColumn(NamedTuple):
+@dataclass
+class MaterializedColumn:
     name: ColumnName
     details: MaterializedColumnDetails
+    is_nullable: bool
+
+    @property
+    def type(self) -> str:
+        if self.is_nullable:
+            return "Nullable(String)"
+        else:
+            return "String"
+
+    def get_expression_and_parameters(self) -> tuple[str, dict[str, Any]]:
+        if self.is_nullable:
+            return (
+                f"JSONExtract({self.details.table_column}, %(property_name)s, %(property_type)s)",
+                {"property_name": self.details.property_name, "property_type": self.type},
+            )
+        else:
+            return (
+                trim_quotes_expr(f"JSONExtractRaw({self.details.table_column}, %(property)s)"),
+                {"property": self.details.property_name},
+            )
 
     @staticmethod
     def get_all(table: TablesWithMaterializedColumns) -> Iterator[MaterializedColumn]:
         rows = sync_execute(
             """
-            SELECT name, comment
+            SELECT name, comment, type like 'Nullable(%%)' as is_nullable
             FROM system.columns
             WHERE database = %(database)s
                 AND table = %(table)s
@@ -58,8 +81,8 @@ def get_all(table: TablesWithMaterializedColumns) -> Iterator[MaterializedColumn
             {"database": CLICKHOUSE_DATABASE, "table": table},
         )
 
-        for name, comment in rows:
-            yield MaterializedColumn(name, MaterializedColumnDetails.from_column_comment(comment))
+        for name, comment, is_nullable in rows:
+            yield MaterializedColumn(name, MaterializedColumnDetails.from_column_comment(comment), is_nullable)
 
     @staticmethod
     def get(table: TablesWithMaterializedColumns, column_name: ColumnName) -> MaterializedColumn:
@@ -111,22 +134,24 @@ def from_column_comment(cls, comment: str) -> MaterializedColumnDetails:
 
 def get_materialized_columns(
     table: TablesWithMaterializedColumns,
-    exclude_disabled_columns: bool = False,
-) -> dict[tuple[PropertyName, TableColumn], ColumnName]:
-    if not get_instance_setting("MATERIALIZED_COLUMNS_ENABLED"):
-        return {}
-
+) -> dict[tuple[PropertyName, TableColumn], MaterializedColumn]:
     return {
-        (column.details.property_name, column.details.table_column): column.name
+        (column.details.property_name, column.details.table_column): column
         for column in MaterializedColumn.get_all(table)
-        if not (exclude_disabled_columns and column.details.is_disabled)
     }
 
 
+@cache_for(timedelta(minutes=15))
+def get_enabled_materialized_columns(
+    table: TablesWithMaterializedColumns,
+) -> dict[tuple[PropertyName, TableColumn], MaterializedColumn]:
+    return {k: column for k, column in get_materialized_columns(table).items() if not column.details.is_disabled}
+
+
 def get_cluster() -> ClickhouseCluster:
     extra_hosts = []
     for host_config in map(copy, CLICKHOUSE_PER_TEAM_SETTINGS.values()):
-        extra_hosts.append(ConnectionInfo(host_config.pop("host"), host_config.pop("port", None)))
+        extra_hosts.append(ConnectionInfo(host_config.pop("host")))
         assert len(host_config) == 0, f"unexpected values: {host_config!r}"
     return ClickhouseCluster(default_client(), extra_hosts=extra_hosts)
 
@@ -161,6 +186,10 @@ def map_data_nodes(self, cluster: ClickhouseCluster, fn: Callable[[Client], T])
 }
 
 
+def get_minmax_index_name(column: str) -> str:
+    return f"minmax_{column}"
+
+
 @dataclass
 class CreateColumnOnDataNodesTask:
     table: str
@@ -169,20 +198,17 @@ class CreateColumnOnDataNodesTask:
     add_column_comment: bool
 
     def execute(self, client: Client) -> None:
+        expression, parameters = self.column.get_expression_and_parameters()
         actions = [
-            f"""
-            ADD COLUMN IF NOT EXISTS {self.column.name} VARCHAR
-                MATERIALIZED {TRIM_AND_EXTRACT_PROPERTY.format(table_column=self.column.details.table_column)}
-            """,
+            f"ADD COLUMN IF NOT EXISTS {self.column.name} {self.column.type} MATERIALIZED {expression}",
         ]
-        parameters = {"property": self.column.details.property_name}
 
         if self.add_column_comment:
             actions.append(f"COMMENT COLUMN {self.column.name} %(comment)s")
             parameters["comment"] = self.column.details.as_column_comment()
 
         if self.create_minmax_index:
-            index_name = f"minmax_{self.column.name}"
+            index_name = get_minmax_index_name(self.column.name)
             actions.append(f"ADD INDEX IF NOT EXISTS {index_name} {self.column.name} TYPE minmax GRANULARITY 1")
 
         client.execute(
@@ -201,7 +227,7 @@ def execute(self, client: Client) -> None:
         client.execute(
             f"""
             ALTER TABLE {self.table}
-                ADD COLUMN IF NOT EXISTS {self.column.name} VARCHAR,
+                ADD COLUMN IF NOT EXISTS {self.column.name} {self.column.type},
                 COMMENT COLUMN {self.column.name} %(comment)s
             """,
             {"comment": self.column.details.as_column_comment()},
@@ -215,10 +241,11 @@ def materialize(
     column_name: ColumnName | None = None,
     table_column: TableColumn = DEFAULT_TABLE_COLUMN,
     create_minmax_index=not TEST,
-) -> ColumnName | None:
-    if (property, table_column) in get_materialized_columns(table):
+    is_nullable: bool = False,
+) -> MaterializedColumn:
+    if existing_column := get_materialized_columns(table).get((property, table_column)):
         if TEST:
-            return None
+            return existing_column
 
         raise ValueError(f"Property already materialized. table={table}, property={property}, column={table_column}")
 
@@ -235,6 +262,7 @@ def materialize(
             property_name=property,
             is_disabled=False,
         ),
+        is_nullable=is_nullable,
     )
 
     table_info.map_data_nodes(
@@ -255,70 +283,112 @@ def materialize(
             ).execute
         ).result()
 
-    return column.name
+    return column
 
 
 @dataclass
 class UpdateColumnCommentTask:
     table: str
-    column: MaterializedColumn
+    columns: list[MaterializedColumn]
 
     def execute(self, client: Client) -> None:
+        actions = []
+        parameters = {}
+        for i, column in enumerate(self.columns):
+            parameter_name = f"comment_{i}"
+            actions.append(f"COMMENT COLUMN {column.name} %({parameter_name})s")
+            parameters[parameter_name] = column.details.as_column_comment()
+
         client.execute(
-            f"ALTER TABLE {self.table} COMMENT COLUMN {self.column.name} %(comment)s",
-            {"comment": self.column.details.as_column_comment()},
+            f"ALTER TABLE {self.table} " + ", ".join(actions),
+            parameters,
             settings={"alter_sync": 2 if TEST else 1},
         )
 
 
-def update_column_is_disabled(table: TablesWithMaterializedColumns, column_name: str, is_disabled: bool) -> None:
+def update_column_is_disabled(
+    table: TablesWithMaterializedColumns, column_names: Iterable[str], is_disabled: bool
+) -> None:
     cluster = get_cluster()
     table_info = tables[table]
 
+    columns = [MaterializedColumn.get(table, column_name) for column_name in column_names]
+
     cluster.map_all_hosts(
         UpdateColumnCommentTask(
             table_info.read_table,
-            MaterializedColumn(
-                name=column_name,
-                details=replace(
-                    MaterializedColumn.get(table, column_name).details,
-                    is_disabled=is_disabled,
-                ),
-            ),
+            [replace(column, details=replace(column.details, is_disabled=is_disabled)) for column in columns],
         ).execute
     ).result()
 
 
+def check_index_exists(client: Client, table: str, index: str) -> bool:
+    [(count,)] = client.execute(
+        """
+        SELECT count()
+        FROM system.data_skipping_indices
+        WHERE database = currentDatabase() AND table = %(table)s AND name = %(name)s
+        """,
+        {"table": table, "name": index},
+    )
+    assert 1 >= count >= 0
+    return bool(count)
+
+
+def check_column_exists(client: Client, table: str, column: str) -> bool:
+    [(count,)] = client.execute(
+        """
+        SELECT count()
+        FROM system.columns
+        WHERE database = currentDatabase() AND table = %(table)s AND name = %(name)s
+        """,
+        {"table": table, "name": column},
+    )
+    assert 1 >= count >= 0
+    return bool(count)
+
+
 @dataclass
 class DropColumnTask:
     table: str
-    column_name: str
+    column_names: list[str]
     try_drop_index: bool
 
     def execute(self, client: Client) -> None:
-        # XXX: copy/pasted from create task
-        if self.try_drop_index:
-            index_name = f"minmax_{self.column_name}"
+        actions = []
+
+        for column_name in self.column_names:
+            if self.try_drop_index:
+                index_name = get_minmax_index_name(column_name)
+                drop_index_action = f"DROP INDEX IF EXISTS {index_name}"
+                if check_index_exists(client, self.table, index_name):
+                    actions.append(drop_index_action)
+                else:
+                    logger.info("Skipping %r, nothing to do...", drop_index_action)
+
+            drop_column_action = f"DROP COLUMN IF EXISTS {column_name}"
+            if check_column_exists(client, self.table, column_name):
+                actions.append(drop_column_action)
+            else:
+                logger.info("Skipping %r, nothing to do...", drop_column_action)
+
+        if actions:
             client.execute(
-                f"ALTER TABLE {self.table} DROP INDEX IF EXISTS {index_name}",
+                f"ALTER TABLE {self.table} " + ", ".join(actions),
                 settings={"alter_sync": 2 if TEST else 1},
             )
 
-        client.execute(
-            f"ALTER TABLE {self.table} DROP COLUMN IF EXISTS {self.column_name}",
-            settings={"alter_sync": 2 if TEST else 1},
-        )
-
 
-def drop_column(table: TablesWithMaterializedColumns, column_name: str) -> None:
+def drop_column(table: TablesWithMaterializedColumns, column_names: Iterable[str]) -> None:
     cluster = get_cluster()
     table_info = tables[table]
+    column_names = [*column_names]
 
     if isinstance(table_info, ShardedTableInfo):
         cluster.map_all_hosts(
             DropColumnTask(
                 table_info.dist_table,
-                column_name,
+                column_names,
                 try_drop_index=False,  # no indexes on distributed tables
             ).execute
         ).result()
@@ -327,7 +397,7 @@ def drop_column(table: TablesWithMaterializedColumns, column_name: str) -> None:
         cluster,
         DropColumnTask(
             table_info.data_table,
-            column_name,
+            column_names,
             try_drop_index=True,
         ).execute,
     ).result()
@@ -345,12 +415,13 @@ def execute(self, client: Client) -> None:
         # Note that for this to work all inserts should list columns explicitly
         # Improve this if https://github.com/ClickHouse/ClickHouse/issues/27730 ever gets resolved
         for column in self.columns:
+            expression, parameters = column.get_expression_and_parameters()
             client.execute(
                 f"""
                 ALTER TABLE {self.table}
-                MODIFY COLUMN {column.name} VARCHAR DEFAULT {TRIM_AND_EXTRACT_PROPERTY.format(table_column=column.details.table_column)}
+                MODIFY COLUMN {column.name} {column.type} DEFAULT {expression}
                 """,
-                {"property": column.details.property_name},
+                parameters,
                 settings=self.test_settings,
             )
 
@@ -373,7 +444,7 @@ def execute(self, client: Client) -> None:
 
 def backfill_materialized_columns(
     table: TableWithProperties,
-    properties: list[tuple[PropertyName, TableColumn]],
+    columns: Iterable[MaterializedColumn],
     backfill_period: timedelta,
     test_settings=None,
 ) -> None:
@@ -382,25 +453,14 @@ def backfill_materialized_columns(
 
     This will require reading and writing a lot of data on clickhouse disk.
     """
-
-    if len(properties) == 0:
-        return
-
     cluster = get_cluster()
     table_info = tables[table]
 
-    # TODO: this will eventually need to handle duplicates
-    materialized_columns = {
-        (column.details.property_name, column.details.table_column): column
-        for column in MaterializedColumn.get_all(table)
-    }
-    columns = [materialized_columns[property] for property in properties]
-
     table_info.map_data_nodes(
         cluster,
         BackfillColumnTask(
             table_info.data_table,
-            columns,
+            [*columns],
             backfill_period if table == "events" else None,  # XXX
             test_settings,
         ).execute,
@@ -420,10 +480,10 @@ def _materialized_column_name(
         prefix += f"{SHORT_TABLE_COLUMN_NAME[table_column]}_"
     property_str = re.sub("[^0-9a-zA-Z$]", "_", property)
 
-    existing_materialized_columns = set(get_materialized_columns(table).values())
+    existing_materialized_column_names = {column.name for column in get_materialized_columns(table).values()}
     suffix = ""
 
-    while f"{prefix}{property_str}{suffix}" in existing_materialized_columns:
+    while f"{prefix}{property_str}{suffix}" in existing_materialized_column_names:
         suffix = "_" + generate_random_short_suffix()
 
     return f"{prefix}{property_str}{suffix}"
diff --git a/ee/clickhouse/materialized_columns/test/test_analyze.py b/ee/clickhouse/materialized_columns/test/test_analyze.py
index 6fdb0fb05cb0e..3b225ab670f92 100644
--- a/ee/clickhouse/materialized_columns/test/test_analyze.py
+++ b/ee/clickhouse/materialized_columns/test/test_analyze.py
@@ -49,9 +49,9 @@ def test_mat_columns(self, patch_backfill, patch_materialize):
         materialize_properties_task()
         patch_materialize.assert_has_calls(
             [
-                call("events", "materialize_me", table_column="properties"),
-                call("events", "materialize_me2", table_column="properties"),
-                call("events", "materialize_person_prop", table_column="person_properties"),
-                call("events", "materialize_me3", table_column="properties"),
+                call("events", "materialize_me", table_column="properties", is_nullable=False),
+                call("events", "materialize_me2", table_column="properties", is_nullable=False),
+                call("events", "materialize_person_prop", table_column="person_properties", is_nullable=False),
+                call("events", "materialize_me3", table_column="properties", is_nullable=False),
             ]
         )
diff --git a/ee/clickhouse/materialized_columns/test/test_columns.py b/ee/clickhouse/materialized_columns/test/test_columns.py
index 4cbbef0c4a416..bf0912114359a 100644
--- a/ee/clickhouse/materialized_columns/test/test_columns.py
+++ b/ee/clickhouse/materialized_columns/test/test_columns.py
@@ -1,5 +1,6 @@
 from datetime import timedelta
 from time import sleep
+from collections.abc import Iterable
 from unittest import TestCase
 from unittest.mock import patch
 
@@ -10,11 +11,13 @@
     MaterializedColumnDetails,
     backfill_materialized_columns,
     drop_column,
+    get_enabled_materialized_columns,
     get_materialized_columns,
     materialize,
     update_column_is_disabled,
 )
-from posthog.clickhouse.materialized_columns import TablesWithMaterializedColumns, get_enabled_materialized_columns
+from ee.tasks.materialized_columns import mark_all_materialized
+from posthog.clickhouse.materialized_columns import TablesWithMaterializedColumns
 from posthog.client import sync_execute
 from posthog.conftest import create_clickhouse_tables
 from posthog.constants import GROUP_TYPES_LIMIT
@@ -129,27 +132,20 @@ def test_caching_and_materializing(self):
 
     @patch("secrets.choice", return_value="X")
     def test_materialized_column_naming(self, mock_choice):
-        materialize("events", "$foO();--sqlinject", create_minmax_index=True)
-        mock_choice.return_value = "Y"
-        materialize("events", "$foO();ääsqlinject", create_minmax_index=True)
-        mock_choice.return_value = "Z"
-        materialize("events", "$foO_____sqlinject", create_minmax_index=True)
-        materialize("person", "SoMePrOp", create_minmax_index=True)
+        assert materialize("events", "$foO();--sqlinject", create_minmax_index=True).name == "mat_$foO_____sqlinject"
 
-        self.assertDictContainsSubset(
-            {
-                ("$foO();--sqlinject", "properties"): "mat_$foO_____sqlinject",
-                ("$foO();ääsqlinject", "properties"): "mat_$foO_____sqlinject_YYYY",
-                ("$foO_____sqlinject", "properties"): "mat_$foO_____sqlinject_ZZZZ",
-            },
-            get_materialized_columns("events"),
+        mock_choice.return_value = "Y"
+        assert (
+            materialize("events", "$foO();ääsqlinject", create_minmax_index=True).name == "mat_$foO_____sqlinject_YYYY"
         )
 
-        self.assertEqual(
-            get_materialized_columns("person"),
-            {("SoMePrOp", "properties"): "pmat_SoMePrOp"},
+        mock_choice.return_value = "Z"
+        assert (
+            materialize("events", "$foO_____sqlinject", create_minmax_index=True).name == "mat_$foO_____sqlinject_ZZZZ"
         )
 
+        assert materialize("person", "SoMePrOp", create_minmax_index=True).name == "pmat_SoMePrOp"
+
     def test_backfilling_data(self):
         sync_execute("ALTER TABLE events DROP COLUMN IF EXISTS mat_prop")
         sync_execute("ALTER TABLE events DROP COLUMN IF EXISTS mat_another")
@@ -196,8 +192,10 @@ def test_backfilling_data(self):
             properties={"another": 6},
         )
 
-        materialize("events", "prop", create_minmax_index=True)
-        materialize("events", "another", create_minmax_index=True)
+        columns = [
+            materialize("events", "prop", create_minmax_index=True),
+            materialize("events", "another", create_minmax_index=True),
+        ]
 
         self.assertEqual(self._count_materialized_rows("mat_prop"), 0)
         self.assertEqual(self._count_materialized_rows("mat_another"), 0)
@@ -205,7 +203,7 @@ def test_backfilling_data(self):
         with freeze_time("2021-05-10T14:00:01Z"):
             backfill_materialized_columns(
                 "events",
-                [("prop", "properties"), ("another", "properties")],
+                columns,
                 timedelta(days=50),
                 test_settings={"mutations_sync": "0"},
             )
@@ -240,21 +238,27 @@ def test_backfilling_data(self):
         )
 
     def test_column_types(self):
-        materialize("events", "myprop", create_minmax_index=True)
-
-        expr = "replaceRegexpAll(JSONExtractRaw(properties, 'myprop'), '^\"|\"$', '')"
-        self.assertEqual(("MATERIALIZED", expr), self._get_column_types("mat_myprop"))
+        columns = [
+            materialize("events", "myprop", create_minmax_index=True),
+            materialize("events", "myprop_nullable", create_minmax_index=True, is_nullable=True),
+        ]
+
+        expr_nonnullable = "replaceRegexpAll(JSONExtractRaw(properties, 'myprop'), '^\"|\"$', '')"
+        expr_nullable = "JSONExtract(properties, 'myprop_nullable', 'Nullable(String)')"
+        self.assertEqual(("String", "MATERIALIZED", expr_nonnullable), self._get_column_types("mat_myprop"))
+        self.assertEqual(
+            ("Nullable(String)", "MATERIALIZED", expr_nullable), self._get_column_types("mat_myprop_nullable")
+        )
 
-        backfill_materialized_columns("events", [("myprop", "properties")], timedelta(days=50))
-        self.assertEqual(("DEFAULT", expr), self._get_column_types("mat_myprop"))
+        backfill_materialized_columns("events", columns, timedelta(days=50))
+        self.assertEqual(("String", "DEFAULT", expr_nonnullable), self._get_column_types("mat_myprop"))
+        self.assertEqual(("Nullable(String)", "DEFAULT", expr_nullable), self._get_column_types("mat_myprop_nullable"))
 
-        try:
-            from ee.tasks.materialized_columns import mark_all_materialized
-        except ImportError:
-            pass
-        else:
-            mark_all_materialized()
-            self.assertEqual(("MATERIALIZED", expr), self._get_column_types("mat_myprop"))
+        mark_all_materialized()
+        self.assertEqual(("String", "MATERIALIZED", expr_nonnullable), self._get_column_types("mat_myprop"))
+        self.assertEqual(
+            ("Nullable(String)", "MATERIALIZED", expr_nullable), self._get_column_types("mat_myprop_nullable")
+        )
 
     def _count_materialized_rows(self, column):
         return sync_execute(
@@ -284,7 +288,7 @@ def _get_count_of_mutations_running(self) -> int:
     def _get_column_types(self, column: str):
         return sync_execute(
             """
-            SELECT default_kind, default_expression
+            SELECT type, default_kind, default_expression
             FROM system.columns
             WHERE database = %(database)s AND table = %(table)s AND name = %(column)s
             """,
@@ -297,42 +301,119 @@ def _get_column_types(self, column: str):
 
     def test_lifecycle(self):
         table: TablesWithMaterializedColumns = "events"
-        property: PropertyName = "myprop"
+        property_names = ["foo", "bar"]
         source_column: TableColumn = "properties"
 
-        # create the materialized column
-        destination_column = materialize(table, property, table_column=source_column, create_minmax_index=True)
-        assert destination_column is not None
-
-        # ensure it exists everywhere
-        key = (property, source_column)
-        assert get_materialized_columns(table)[key] == destination_column
-        assert MaterializedColumn.get(table, destination_column) == MaterializedColumn(
-            destination_column,
-            MaterializedColumnDetails(source_column, property, is_disabled=False),
+        # create materialized columns
+        materialized_columns = {}
+        for property_name in property_names:
+            materialized_columns[property_name] = materialize(
+                table, property_name, table_column=source_column, create_minmax_index=True
+            ).name
+
+        assert set(property_names) == materialized_columns.keys()
+
+        # ensure they exist everywhere
+        for property_name, destination_column in materialized_columns.items():
+            key = (property_name, source_column)
+            assert get_materialized_columns(table)[key].name == destination_column
+            assert MaterializedColumn.get(table, destination_column) == MaterializedColumn(
+                destination_column,
+                MaterializedColumnDetails(source_column, property_name, is_disabled=False),
+                is_nullable=False,
+            )
+
+        # disable them and ensure updates apply as needed
+        update_column_is_disabled(table, materialized_columns.values(), is_disabled=True)
+        for property_name, destination_column in materialized_columns.items():
+            key = (property_name, source_column)
+            assert get_materialized_columns(table)[key].name == destination_column
+            assert MaterializedColumn.get(table, destination_column) == MaterializedColumn(
+                destination_column,
+                MaterializedColumnDetails(source_column, property_name, is_disabled=True),
+                is_nullable=False,
+            )
+
+        # re-enable them and ensure updates apply as needed
+        update_column_is_disabled(table, materialized_columns.values(), is_disabled=False)
+        for property_name, destination_column in materialized_columns.items():
+            key = (property_name, source_column)
+            assert get_materialized_columns(table)[key].name == destination_column
+            assert MaterializedColumn.get(table, destination_column) == MaterializedColumn(
+                destination_column,
+                MaterializedColumnDetails(source_column, property_name, is_disabled=False),
+                is_nullable=False,
+            )
+
+        # drop them and ensure updates apply as needed
+        drop_column(table, materialized_columns.values())
+        for property_name, destination_column in materialized_columns.items():
+            key = (property_name, source_column)
+            assert key not in get_materialized_columns(table)
+            with self.assertRaises(ValueError):
+                MaterializedColumn.get(table, destination_column)
+
+    def _get_latest_mutation_id(self, table: str) -> str:
+        [(mutation_id,)] = sync_execute(
+            """
+            SELECT max(mutation_id)
+            FROM system.mutations
+            WHERE
+                database = currentDatabase()
+                AND table = %(table)s
+            """,
+            {"table": table},
         )
+        return mutation_id
+
+    def _get_mutations_since_id(self, table: str, id: str) -> Iterable[str]:
+        return [
+            command
+            for (command,) in sync_execute(
+                """
+                SELECT command
+                FROM system.mutations
+                WHERE
+                    database = currentDatabase()
+                    AND table = %(table)s
+                    AND mutation_id > %(mutation_id)s
+                ORDER BY mutation_id
+                """,
+                {"table": table, "mutation_id": id},
+            )
+        ]
 
-        # disable it and ensure updates apply as needed
-        update_column_is_disabled(table, destination_column, is_disabled=True)
-        assert get_materialized_columns(table)[key] == destination_column
-        assert key not in get_materialized_columns(table, exclude_disabled_columns=True)
-        assert MaterializedColumn.get(table, destination_column) == MaterializedColumn(
-            destination_column,
-            MaterializedColumnDetails(source_column, property, is_disabled=True),
+    def test_drop_optimized_no_index(self):
+        table: TablesWithMaterializedColumns = (
+            "person"  # little bit easier than events because no shard awareness needed
         )
+        property: PropertyName = "myprop"
+        source_column: TableColumn = "properties"
+
+        destination_column = materialize(table, property, table_column=source_column, create_minmax_index=False)
+
+        latest_mutation_id_before_drop = self._get_latest_mutation_id(table)
 
-        # re-enable it and ensure updates apply as needed
-        update_column_is_disabled(table, destination_column, is_disabled=False)
-        assert get_materialized_columns(table, exclude_disabled_columns=False)[key] == destination_column
-        assert get_materialized_columns(table, exclude_disabled_columns=True)[key] == destination_column
-        assert MaterializedColumn.get(table, destination_column) == MaterializedColumn(
-            destination_column,
-            MaterializedColumnDetails(source_column, property, is_disabled=False),
+        drop_column(table, destination_column.name)
+
+        mutations_ran = self._get_mutations_since_id(table, latest_mutation_id_before_drop)
+        assert not any("DROP INDEX" in mutation for mutation in mutations_ran)
+
+    def test_drop_optimized_no_column(self):
+        table: TablesWithMaterializedColumns = (
+            "person"  # little bit easier than events because no shard awareness needed
         )
+        property: PropertyName = "myprop"
+        source_column: TableColumn = "properties"
 
-        # drop it and ensure updates apply as needed
-        drop_column(table, destination_column)
-        assert key not in get_materialized_columns(table, exclude_disabled_columns=False)
-        assert key not in get_materialized_columns(table, exclude_disabled_columns=True)
-        with self.assertRaises(ValueError):
-            MaterializedColumn.get(table, destination_column)
+        # create the materialized column
+        destination_column = materialize(table, property, table_column=source_column, create_minmax_index=False)
+
+        sync_execute(f"ALTER TABLE {table} DROP COLUMN {destination_column.name}", settings={"alter_sync": 1})
+
+        latest_mutation_id_before_drop = self._get_latest_mutation_id(table)
+
+        drop_column(table, destination_column.name)
+
+        mutations_ran = self._get_mutations_since_id(table, latest_mutation_id_before_drop)
+        assert not any("DROP COLUMN" in mutation for mutation in mutations_ran)
diff --git a/ee/clickhouse/models/test/test_cohort.py b/ee/clickhouse/models/test/test_cohort.py
index 8af41154c48a5..1600584169a28 100644
--- a/ee/clickhouse/models/test/test_cohort.py
+++ b/ee/clickhouse/models/test/test_cohort.py
@@ -1,4 +1,5 @@
 from datetime import datetime, timedelta
+from typing import Optional
 
 from django.utils import timezone
 from freezegun import freeze_time
@@ -8,12 +9,13 @@
 from posthog.models.action import Action
 from posthog.models.cohort import Cohort
 from posthog.models.cohort.sql import GET_COHORTPEOPLE_BY_COHORT_ID
-from posthog.models.cohort.util import format_filter_query, get_person_ids_by_cohort_id
+from posthog.models.cohort.util import format_filter_query
 from posthog.models.filters import Filter
 from posthog.models.organization import Organization
 from posthog.models.person import Person
 from posthog.models.property.util import parse_prop_grouped_clauses
 from posthog.models.team import Team
+from posthog.queries.person_distinct_id_query import get_team_distinct_ids_query
 from posthog.queries.util import PersonPropertiesMode
 from posthog.schema import PersonsOnEventsMode
 from posthog.test.base import (
@@ -25,6 +27,7 @@
     snapshot_clickhouse_insert_cohortpeople_queries,
     snapshot_clickhouse_queries,
 )
+from posthog.models.person.sql import GET_LATEST_PERSON_SQL, GET_PERSON_IDS_BY_FILTER
 
 
 def _create_action(**kwargs):
@@ -34,12 +37,44 @@ def _create_action(**kwargs):
     return action
 
 
+def get_person_ids_by_cohort_id(
+    team_id: int,
+    cohort_id: int,
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+):
+    from posthog.models.property.util import parse_prop_grouped_clauses
+
+    filter = Filter(data={"properties": [{"key": "id", "value": cohort_id, "type": "cohort"}]})
+    filter_query, filter_params = parse_prop_grouped_clauses(
+        team_id=team_id,
+        property_group=filter.property_groups,
+        table_name="pdi",
+        hogql_context=filter.hogql_context,
+    )
+
+    results = sync_execute(
+        GET_PERSON_IDS_BY_FILTER.format(
+            person_query=GET_LATEST_PERSON_SQL,
+            distinct_query=filter_query,
+            query="",
+            GET_TEAM_PERSON_DISTINCT_IDS=get_team_distinct_ids_query(team_id),
+            offset="OFFSET %(offset)s" if offset else "",
+            limit="ORDER BY _timestamp ASC LIMIT %(limit)s" if limit else "",
+        ),
+        {**filter_params, "team_id": team_id, "offset": offset, "limit": limit},
+    )
+
+    return [str(row[0]) for row in results]
+
+
 class TestCohort(ClickhouseTestMixin, BaseTest):
-    def _get_cohortpeople(self, cohort: Cohort):
+    def _get_cohortpeople(self, cohort: Cohort, *, team_id: Optional[int] = None):
+        team_id = team_id or cohort.team_id
         return sync_execute(
             GET_COHORTPEOPLE_BY_COHORT_ID,
             {
-                "team_id": self.team.pk,
+                "team_id": team_id,
                 "cohort_id": cohort.pk,
                 "version": cohort.version,
             },
@@ -452,7 +487,7 @@ def test_cohort_get_person_ids_by_cohort_id(self):
             name="cohort1",
         )
 
-        results = get_person_ids_by_cohort_id(self.team, cohort.id)
+        results = get_person_ids_by_cohort_id(self.team.pk, cohort.id)
         self.assertEqual(len(results), 2)
         self.assertIn(str(user1.uuid), results)
         self.assertIn(str(user3.uuid), results)
@@ -468,7 +503,7 @@ def test_insert_by_distinct_id_or_email(self):
         cohort = Cohort.objects.create(team=self.team, groups=[], is_static=True)
         cohort.insert_users_by_list(["1", "123"])
         cohort = Cohort.objects.get()
-        results = get_person_ids_by_cohort_id(self.team, cohort.id)
+        results = get_person_ids_by_cohort_id(self.team.pk, cohort.id)
         self.assertEqual(len(results), 2)
         self.assertEqual(cohort.is_calculating, False)
 
@@ -483,12 +518,12 @@ def test_insert_by_distinct_id_or_email(self):
 
         #  If we accidentally call calculate_people it shouldn't erase people
         cohort.calculate_people_ch(pending_version=0)
-        results = get_person_ids_by_cohort_id(self.team, cohort.id)
+        results = get_person_ids_by_cohort_id(self.team.pk, cohort.id)
         self.assertEqual(len(results), 3)
 
         # if we add people again, don't increase the number of people in cohort
         cohort.insert_users_by_list(["123"])
-        results = get_person_ids_by_cohort_id(self.team, cohort.id)
+        results = get_person_ids_by_cohort_id(self.team.pk, cohort.id)
         self.assertEqual(len(results), 3)
 
     @snapshot_clickhouse_insert_cohortpeople_queries
@@ -1370,3 +1405,45 @@ def test_cohort_versioning(self):
         # Should have p1 in this cohort even if version is different
         results = self._get_cohortpeople(cohort1)
         self.assertEqual(len(results), 1)
+
+    def test_calculate_people_ch_in_multiteam_project(self):
+        # Create another team in the same project
+        team2 = Team.objects.create(organization=self.organization, project=self.team.project)
+
+        # Create people in team 1
+        _person1_team1 = _create_person(
+            team_id=self.team.pk,
+            distinct_ids=["person1"],
+            properties={"$some_prop": "else"},
+        )
+        person2_team1 = _create_person(
+            team_id=self.team.pk,
+            distinct_ids=["person2"],
+            properties={"$some_prop": "something"},
+        )
+        # Create people in team 2 with same property
+        person1_team2 = _create_person(
+            team_id=team2.pk,
+            distinct_ids=["person1_team2"],
+            properties={"$some_prop": "something"},
+        )
+        _person2_team2 = _create_person(
+            team_id=team2.pk,
+            distinct_ids=["person2_team2"],
+            properties={"$some_prop": "else"},
+        )
+        # Create cohort in team 2 (but same project as team 1)
+        shared_cohort = Cohort.objects.create(
+            team=team2,
+            groups=[{"properties": [{"key": "$some_prop", "value": "something", "type": "person"}]}],
+            name="shared cohort",
+        )
+        # Calculate cohort
+        shared_cohort.calculate_people_ch(pending_version=0)
+
+        # Verify shared_cohort is now calculated for both teams
+        results_team1 = self._get_cohortpeople(shared_cohort, team_id=self.team.pk)
+        results_team2 = self._get_cohortpeople(shared_cohort, team_id=team2.pk)
+
+        self.assertCountEqual([r[0] for r in results_team1], [person2_team1.uuid])
+        self.assertCountEqual([r[0] for r in results_team2], [person1_team2.uuid])
diff --git a/ee/clickhouse/queries/event_query.py b/ee/clickhouse/queries/event_query.py
index 3f7857fd9a970..64f08da69d6bf 100644
--- a/ee/clickhouse/queries/event_query.py
+++ b/ee/clickhouse/queries/event_query.py
@@ -7,7 +7,6 @@
 from posthog.models.filters.path_filter import PathFilter
 from posthog.models.filters.properties_timeline_filter import PropertiesTimelineFilter
 from posthog.models.filters.retention_filter import RetentionFilter
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
 from posthog.models.filters.stickiness_filter import StickinessFilter
 from posthog.models.property import PropertyName
 from posthog.models.team import Team
@@ -25,7 +24,6 @@ def __init__(
             PathFilter,
             RetentionFilter,
             StickinessFilter,
-            SessionRecordingsFilter,
             PropertiesTimelineFilter,
         ],
         team: Team,
diff --git a/ee/clickhouse/queries/funnels/funnel_correlation.py b/ee/clickhouse/queries/funnels/funnel_correlation.py
index 3e5b69005d689..0b909c84b398e 100644
--- a/ee/clickhouse/queries/funnels/funnel_correlation.py
+++ b/ee/clickhouse/queries/funnels/funnel_correlation.py
@@ -13,7 +13,7 @@
 
 from ee.clickhouse.queries.column_optimizer import EnterpriseColumnOptimizer
 from ee.clickhouse.queries.groups_join_query import GroupsJoinQuery
-from posthog.clickhouse.materialized_columns import get_enabled_materialized_columns
+from posthog.clickhouse.materialized_columns import get_materialized_column_for_property
 from posthog.constants import (
     AUTOCAPTURE_EVENT,
     TREND_FILTER_TYPE_ACTIONS,
@@ -156,8 +156,6 @@ def properties_to_include(self) -> list[str]:
         ):
             # When dealing with properties, make sure funnel response comes with properties
             # so we don't have to join on persons/groups to get these properties again
-            mat_event_cols = get_enabled_materialized_columns("events")
-
             for property_name in cast(list, self._filter.correlation_property_names):
                 if self._filter.aggregation_group_type_index is not None:
                     continue  # We don't support group properties on events at this time
@@ -165,10 +163,11 @@ def properties_to_include(self) -> list[str]:
                     if "$all" == property_name:
                         return [f"person_properties"]
 
-                    possible_mat_col = mat_event_cols.get((property_name, "person_properties"))
-
-                    if possible_mat_col is not None:
-                        props_to_include.append(possible_mat_col)
+                    possible_mat_col = get_materialized_column_for_property(
+                        "events", "person_properties", property_name
+                    )
+                    if possible_mat_col is not None and not possible_mat_col.is_nullable:
+                        props_to_include.append(possible_mat_col.name)
                     else:
                         props_to_include.append(f"person_properties")
 
diff --git a/ee/clickhouse/queries/funnels/test/test_funnel_correlations_persons.py b/ee/clickhouse/queries/funnels/test/test_funnel_correlations_persons.py
index 4617ffde3c2d5..c6954e15eed9b 100644
--- a/ee/clickhouse/queries/funnels/test/test_funnel_correlations_persons.py
+++ b/ee/clickhouse/queries/funnels/test/test_funnel_correlations_persons.py
@@ -251,6 +251,7 @@ def test_create_funnel_correlation_cohort(self, _insert_cohort_from_insight_filt
                 "funnel_correlation_person_entity": "{'id': 'positively_related', 'type': 'events'}",
                 "funnel_correlation_person_converted": "TrUe",
             },
+            self.team.pk,
         )
 
         insert_cohort_from_insight_filter(cohort_id, params)
diff --git a/ee/clickhouse/queries/related_actors_query.py b/ee/clickhouse/queries/related_actors_query.py
index 4b6198c222710..99817998d7119 100644
--- a/ee/clickhouse/queries/related_actors_query.py
+++ b/ee/clickhouse/queries/related_actors_query.py
@@ -41,7 +41,7 @@ def __init__(
     def run(self) -> list[SerializedActor]:
         results: list[SerializedActor] = []
         results.extend(self._query_related_people())
-        for group_type_mapping in GroupTypeMapping.objects.filter(team_id=self.team.pk):
+        for group_type_mapping in GroupTypeMapping.objects.filter(project_id=self.team.project_id):
             results.extend(self._query_related_groups(group_type_mapping.group_type_index))
         return results
 
diff --git a/ee/clickhouse/views/experiments.py b/ee/clickhouse/views/experiments.py
index 391fc1a6aa5ab..b8444d819bafa 100644
--- a/ee/clickhouse/views/experiments.py
+++ b/ee/clickhouse/views/experiments.py
@@ -429,8 +429,8 @@ def update(self, instance: Experiment, validated_data: dict, *args: Any, **kwarg
                     {"key": "test", "name": "Test Variant", "rollout_percentage": 50},
                 ]
 
-                filters = {
-                    "groups": [{"properties": properties, "rollout_percentage": 100}],
+                feature_flag_filters = {
+                    "groups": feature_flag.filters.get("groups", []),
                     "multivariate": {"variants": variants or default_variants},
                     "aggregation_group_type_index": aggregation_group_type_index,
                     "holdout_groups": holdout_groups,
@@ -438,7 +438,7 @@ def update(self, instance: Experiment, validated_data: dict, *args: Any, **kwarg
 
                 existing_flag_serializer = FeatureFlagSerializer(
                     feature_flag,
-                    data={"filters": filters},
+                    data={"filters": feature_flag_filters},
                     partial=True,
                     context=self.context,
                 )
diff --git a/ee/clickhouse/views/groups.py b/ee/clickhouse/views/groups.py
index 4970a770854a2..be692dc597525 100644
--- a/ee/clickhouse/views/groups.py
+++ b/ee/clickhouse/views/groups.py
@@ -35,7 +35,9 @@ class GroupsTypesViewSet(TeamAndOrgViewSetMixin, mixins.ListModelMixin, viewsets
     @action(detail=False, methods=["PATCH"], name="Update group types metadata")
     def update_metadata(self, request: request.Request, *args, **kwargs):
         for row in cast(list[dict], request.data):
-            instance = GroupTypeMapping.objects.get(team=self.team, group_type_index=row["group_type_index"])
+            instance = GroupTypeMapping.objects.get(
+                project_id=self.team.project_id, group_type_index=row["group_type_index"]
+            )
             serializer = self.get_serializer(instance, data=row)
             serializer.is_valid(raise_exception=True)
             serializer.save()
diff --git a/ee/clickhouse/views/test/__snapshots__/test_clickhouse_experiments.ambr b/ee/clickhouse/views/test/__snapshots__/test_clickhouse_experiments.ambr
index a5b7547779592..983cdf00b5aa0 100644
--- a/ee/clickhouse/views/test/__snapshots__/test_clickhouse_experiments.ambr
+++ b/ee/clickhouse/views/test/__snapshots__/test_clickhouse_experiments.ambr
@@ -1,17 +1,5 @@
 # serializer version: 1
 # name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results
-  '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS value,
@@ -27,7 +15,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results.2
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT countIf(steps = 1) step_1,
@@ -106,19 +94,86 @@
   GROUP BY prop
   '''
 # ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_and_events_out_of_time_range_timezones
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results.2
   '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  /* user_id:0 request:_snapshot_ */
+  SELECT countIf(steps = 1) step_1,
+         countIf(steps = 2) step_2,
+         avg(step_1_average_conversion_time_inner) step_1_average_conversion_time,
+         median(step_1_median_conversion_time_inner) step_1_median_conversion_time,
+         prop
+  FROM
+    (SELECT aggregation_target,
+            steps,
+            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
+            median(step_1_conversion_time) step_1_median_conversion_time_inner ,
+            prop
+     FROM
+       (SELECT aggregation_target,
+               steps,
+               max(steps) over (PARTITION BY aggregation_target,
+                                             prop) as max_steps,
+                               step_1_conversion_time ,
+                               prop
+        FROM
+          (SELECT *,
+                  if(latest_0 <= latest_1
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, 2, 1) AS steps ,
+                  if(isNotNull(latest_1)
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
+                  prop
+           FROM
+             (SELECT aggregation_target, timestamp, step_0,
+                                                    latest_0,
+                                                    step_1,
+                                                    min(latest_1) over (PARTITION by aggregation_target,
+                                                                                     prop
+                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1 ,
+                                                                       if(has([['test'], ['control'], ['']], prop), prop, ['Other']) as prop
+              FROM
+                (SELECT *,
+                        if(notEmpty(arrayFilter(x -> notEmpty(x), prop_vals)), prop_vals, ['']) as prop
+                 FROM
+                   (SELECT e.timestamp as timestamp,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
+                           if(event = '$pageview', 1, 0) as step_0,
+                           if(step_0 = 1, timestamp, null) as latest_0,
+                           if(event = '$pageleave', 1, 0) as step_1,
+                           if(step_1 = 1, timestamp, null) as latest_1,
+                           array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS prop_basic,
+                           prop_basic as prop,
+                           argMinIf(prop, timestamp, notEmpty(arrayFilter(x -> notEmpty(x), prop))) over (PARTITION by aggregation_target) as prop_vals
+                    FROM events e
+                    LEFT OUTER JOIN
+                      (SELECT distinct_id,
+                              argMax(person_id, version) as person_id
+                       FROM person_distinct_id2
+                       WHERE team_id = 99999
+                         AND distinct_id IN
+                           (SELECT distinct_id
+                            FROM events
+                            WHERE team_id = 99999
+                              AND event IN ['$pageleave', '$pageview']
+                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC') )
+                       GROUP BY distinct_id
+                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
+                    WHERE team_id = 99999
+                      AND event IN ['$pageleave', '$pageview']
+                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC')
+                      AND (step_0 = 1
+                           OR step_1 = 1) )))
+           WHERE step_0 = 1 ))
+     GROUP BY aggregation_target,
+              steps,
+              prop
+     HAVING steps = max(max_steps))
+  GROUP BY prop
   '''
 # ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_and_events_out_of_time_range_timezones.1
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_and_events_out_of_time_range_timezones
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS value,
@@ -134,6 +189,85 @@
   OFFSET 0
   '''
 # ---
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_and_events_out_of_time_range_timezones.1
+  '''
+  /* user_id:0 request:_snapshot_ */
+  SELECT countIf(steps = 1) step_1,
+         countIf(steps = 2) step_2,
+         avg(step_1_average_conversion_time_inner) step_1_average_conversion_time,
+         median(step_1_median_conversion_time_inner) step_1_median_conversion_time,
+         prop
+  FROM
+    (SELECT aggregation_target,
+            steps,
+            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
+            median(step_1_conversion_time) step_1_median_conversion_time_inner ,
+            prop
+     FROM
+       (SELECT aggregation_target,
+               steps,
+               max(steps) over (PARTITION BY aggregation_target,
+                                             prop) as max_steps,
+                               step_1_conversion_time ,
+                               prop
+        FROM
+          (SELECT *,
+                  if(latest_0 <= latest_1
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, 2, 1) AS steps ,
+                  if(isNotNull(latest_1)
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
+                  prop
+           FROM
+             (SELECT aggregation_target, timestamp, step_0,
+                                                    latest_0,
+                                                    step_1,
+                                                    min(latest_1) over (PARTITION by aggregation_target,
+                                                                                     prop
+                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1 ,
+                                                                       if(has([['test'], ['control']], prop), prop, ['Other']) as prop
+              FROM
+                (SELECT *,
+                        if(notEmpty(arrayFilter(x -> notEmpty(x), prop_vals)), prop_vals, ['']) as prop
+                 FROM
+                   (SELECT e.timestamp as timestamp,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
+                           if(event = '$pageview', 1, 0) as step_0,
+                           if(step_0 = 1, timestamp, null) as latest_0,
+                           if(event = '$pageleave', 1, 0) as step_1,
+                           if(step_1 = 1, timestamp, null) as latest_1,
+                           array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS prop_basic,
+                           prop_basic as prop,
+                           argMinIf(prop, timestamp, notEmpty(arrayFilter(x -> notEmpty(x), prop))) over (PARTITION by aggregation_target) as prop_vals
+                    FROM events e
+                    LEFT OUTER JOIN
+                      (SELECT distinct_id,
+                              argMax(person_id, version) as person_id
+                       FROM person_distinct_id2
+                       WHERE team_id = 99999
+                         AND distinct_id IN
+                           (SELECT distinct_id
+                            FROM events
+                            WHERE team_id = 99999
+                              AND event IN ['$pageleave', '$pageview']
+                              AND toTimeZone(timestamp, 'Europe/Amsterdam') >= toDateTime('2020-01-01 14:20:21', 'Europe/Amsterdam')
+                              AND toTimeZone(timestamp, 'Europe/Amsterdam') <= toDateTime('2020-01-06 10:00:00', 'Europe/Amsterdam') )
+                       GROUP BY distinct_id
+                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
+                    WHERE team_id = 99999
+                      AND event IN ['$pageleave', '$pageview']
+                      AND toTimeZone(timestamp, 'Europe/Amsterdam') >= toDateTime('2020-01-01 14:20:21', 'Europe/Amsterdam')
+                      AND toTimeZone(timestamp, 'Europe/Amsterdam') <= toDateTime('2020-01-06 10:00:00', 'Europe/Amsterdam')
+                      AND (step_0 = 1
+                           OR step_1 = 1) )))
+           WHERE step_0 = 1 ))
+     GROUP BY aggregation_target,
+              steps,
+              prop
+     HAVING steps = max(max_steps))
+  GROUP BY prop
+  '''
+# ---
 # name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_and_events_out_of_time_range_timezones.2
   '''
   /* user_id:0 request:_snapshot_ */
@@ -213,19 +347,181 @@
   GROUP BY prop
   '''
 # ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants
-  '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.1
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants
+  '''
+  /* user_id:0 request:_snapshot_ */
+  SELECT array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS value,
+         count(*) as count
+  FROM events e
+  WHERE team_id = 99999
+    AND event IN ['$pageleave', '$pageview']
+    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC')
+  GROUP BY value
+  ORDER BY count DESC, value DESC
+  LIMIT 26
+  OFFSET 0
+  '''
+# ---
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.1
+  '''
+  /* user_id:0 request:_snapshot_ */
+  SELECT countIf(steps = 1) step_1,
+         countIf(steps = 2) step_2,
+         avg(step_1_average_conversion_time_inner) step_1_average_conversion_time,
+         median(step_1_median_conversion_time_inner) step_1_median_conversion_time,
+         prop
+  FROM
+    (SELECT aggregation_target,
+            steps,
+            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
+            median(step_1_conversion_time) step_1_median_conversion_time_inner ,
+            prop
+     FROM
+       (SELECT aggregation_target,
+               steps,
+               max(steps) over (PARTITION BY aggregation_target,
+                                             prop) as max_steps,
+                               step_1_conversion_time ,
+                               prop
+        FROM
+          (SELECT *,
+                  if(latest_0 <= latest_1
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, 2, 1) AS steps ,
+                  if(isNotNull(latest_1)
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
+                  prop
+           FROM
+             (SELECT aggregation_target, timestamp, step_0,
+                                                    latest_0,
+                                                    step_1,
+                                                    min(latest_1) over (PARTITION by aggregation_target,
+                                                                                     prop
+                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1 ,
+                                                                       if(has([[''], ['test_1'], ['test'], ['control'], ['unknown_3'], ['unknown_2'], ['unknown_1'], ['test_2']], prop), prop, ['Other']) as prop
+              FROM
+                (SELECT *,
+                        if(notEmpty(arrayFilter(x -> notEmpty(x), prop_vals)), prop_vals, ['']) as prop
+                 FROM
+                   (SELECT e.timestamp as timestamp,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
+                           if(event = '$pageview', 1, 0) as step_0,
+                           if(step_0 = 1, timestamp, null) as latest_0,
+                           if(event = '$pageleave', 1, 0) as step_1,
+                           if(step_1 = 1, timestamp, null) as latest_1,
+                           array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS prop_basic,
+                           prop_basic as prop,
+                           argMinIf(prop, timestamp, notEmpty(arrayFilter(x -> notEmpty(x), prop))) over (PARTITION by aggregation_target) as prop_vals
+                    FROM events e
+                    LEFT OUTER JOIN
+                      (SELECT distinct_id,
+                              argMax(person_id, version) as person_id
+                       FROM person_distinct_id2
+                       WHERE team_id = 99999
+                         AND distinct_id IN
+                           (SELECT distinct_id
+                            FROM events
+                            WHERE team_id = 99999
+                              AND event IN ['$pageleave', '$pageview']
+                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC') )
+                       GROUP BY distinct_id
+                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
+                    WHERE team_id = 99999
+                      AND event IN ['$pageleave', '$pageview']
+                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC')
+                      AND (step_0 = 1
+                           OR step_1 = 1) )))
+           WHERE step_0 = 1 ))
+     GROUP BY aggregation_target,
+              steps,
+              prop
+     HAVING steps = max(max_steps))
+  GROUP BY prop
+  '''
+# ---
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.2
+  '''
+  /* user_id:0 request:_snapshot_ */
+  SELECT countIf(steps = 1) step_1,
+         countIf(steps = 2) step_2,
+         avg(step_1_average_conversion_time_inner) step_1_average_conversion_time,
+         median(step_1_median_conversion_time_inner) step_1_median_conversion_time,
+         prop
+  FROM
+    (SELECT aggregation_target,
+            steps,
+            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
+            median(step_1_conversion_time) step_1_median_conversion_time_inner ,
+            prop
+     FROM
+       (SELECT aggregation_target,
+               steps,
+               max(steps) over (PARTITION BY aggregation_target,
+                                             prop) as max_steps,
+                               step_1_conversion_time ,
+                               prop
+        FROM
+          (SELECT *,
+                  if(latest_0 <= latest_1
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, 2, 1) AS steps ,
+                  if(isNotNull(latest_1)
+                     AND latest_1 <= latest_0 + INTERVAL 14 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
+                  prop
+           FROM
+             (SELECT aggregation_target, timestamp, step_0,
+                                                    latest_0,
+                                                    step_1,
+                                                    min(latest_1) over (PARTITION by aggregation_target,
+                                                                                     prop
+                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1 ,
+                                                                       if(has([[''], ['test_1'], ['test'], ['control'], ['unknown_3'], ['unknown_2'], ['unknown_1'], ['test_2']], prop), prop, ['Other']) as prop
+              FROM
+                (SELECT *,
+                        if(notEmpty(arrayFilter(x -> notEmpty(x), prop_vals)), prop_vals, ['']) as prop
+                 FROM
+                   (SELECT e.timestamp as timestamp,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
+                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
+                           if(event = '$pageview', 1, 0) as step_0,
+                           if(step_0 = 1, timestamp, null) as latest_0,
+                           if(event = '$pageleave', 1, 0) as step_1,
+                           if(step_1 = 1, timestamp, null) as latest_1,
+                           array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS prop_basic,
+                           prop_basic as prop,
+                           argMinIf(prop, timestamp, notEmpty(arrayFilter(x -> notEmpty(x), prop))) over (PARTITION by aggregation_target) as prop_vals
+                    FROM events e
+                    LEFT OUTER JOIN
+                      (SELECT distinct_id,
+                              argMax(person_id, version) as person_id
+                       FROM person_distinct_id2
+                       WHERE team_id = 99999
+                         AND distinct_id IN
+                           (SELECT distinct_id
+                            FROM events
+                            WHERE team_id = 99999
+                              AND event IN ['$pageleave', '$pageview']
+                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC') )
+                       GROUP BY distinct_id
+                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
+                    WHERE team_id = 99999
+                      AND event IN ['$pageleave', '$pageview']
+                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC')
+                      AND (step_0 = 1
+                           OR step_1 = 1) )))
+           WHERE step_0 = 1 ))
+     GROUP BY aggregation_target,
+              steps,
+              prop
+     HAVING steps = max(max_steps))
+  GROUP BY prop
+  '''
+# ---
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_with_hogql_aggregation
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS value,
@@ -241,7 +537,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.2
+# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_with_hogql_aggregation.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT countIf(steps = 1) step_1,
@@ -276,13 +572,13 @@
                                                     min(latest_1) over (PARTITION by aggregation_target,
                                                                                      prop
                                                                         ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1 ,
-                                                                       if(has([[''], ['test_1'], ['test'], ['control'], ['unknown_3'], ['unknown_2'], ['unknown_1'], ['test_2']], prop), prop, ['Other']) as prop
+                                                                       if(has([['test'], ['control'], ['']], prop), prop, ['Other']) as prop
               FROM
                 (SELECT *,
                         if(notEmpty(arrayFilter(x -> notEmpty(x), prop_vals)), prop_vals, ['']) as prop
                  FROM
                    (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
+                           replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(properties, '$account_id'), ''), 'null'), '^"|"$', '') as aggregation_target,
                            if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
                            if(event = '$pageview', 1, 0) as step_0,
                            if(step_0 = 1, timestamp, null) as latest_0,
@@ -320,34 +616,6 @@
   GROUP BY prop
   '''
 # ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_with_hogql_aggregation
-  '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_with_hogql_aggregation.1
-  '''
-  /* user_id:0 request:_snapshot_ */
-  SELECT array(replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '')) AS value,
-         count(*) as count
-  FROM events e
-  WHERE team_id = 99999
-    AND event IN ['$pageleave', '$pageview']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
 # name: ClickhouseTestFunnelExperimentResults.test_experiment_flow_with_event_results_with_hogql_aggregation.2
   '''
   /* user_id:0 request:_snapshot_ */
@@ -428,18 +696,6 @@
   '''
 # ---
 # name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results
-  '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '') AS value,
@@ -458,7 +714,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.2
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(day_start) as date,
@@ -506,7 +762,7 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.3
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.2
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature_flag_response'), '^"|"$', '') AS value,
@@ -526,7 +782,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.4
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.3
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(day_start) as date,
@@ -590,19 +846,71 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results.4
   '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  /* user_id:0 request:_snapshot_ */
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-06 00:00:00', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(6)
+              UNION ALL SELECT toStartOfDay(toDateTime('2020-01-01 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['control', 'test'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            breakdown_value
+           FROM
+             (SELECT person_id,
+                     min(timestamp) as timestamp,
+                     breakdown_value
+              FROM
+                (SELECT pdi.person_id as person_id, timestamp, transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$feature_flag_response'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['control', 'test']), (['control', 'test']), '$$_posthog_breakdown_other_$$') as breakdown_value
+                 FROM events e
+                 INNER JOIN
+                   (SELECT distinct_id,
+                           argMax(person_id, version) as person_id
+                    FROM person_distinct_id2
+                    WHERE team_id = 99999
+                    GROUP BY distinct_id
+                    HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+                 WHERE e.team_id = 99999
+                   AND event = '$feature_flag_called'
+                   AND (((isNull(replaceRegexpAll(JSONExtractRaw(e.properties, 'exclude'), '^"|"$', ''))
+                          OR NOT JSONHas(e.properties, 'exclude')))
+                        AND ((has(['control', 'test'], replaceRegexpAll(JSONExtractRaw(e.properties, '$feature_flag_response'), '^"|"$', '')))
+                             AND (has(['a-b-test'], replaceRegexpAll(JSONExtractRaw(e.properties, '$feature_flag'), '^"|"$', '')))))
+                   AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                   AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC') )
+              GROUP BY person_id,
+                       breakdown_value) AS pdi
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.1
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '') AS value,
@@ -619,7 +927,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.2
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(day_start) as date,
@@ -665,7 +973,7 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.3
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.2
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature_flag_response'), '^"|"$', '') AS value,
@@ -683,7 +991,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.4
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.3
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT [now()] AS date,
@@ -692,19 +1000,16 @@
   LIMIT 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_for_three_test_variants.4
   '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  /* user_id:0 request:_snapshot_ */
+  SELECT [now()] AS date,
+         [0] AS total,
+         '' AS breakdown_value
+  LIMIT 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.1
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '') AS value,
@@ -721,7 +1026,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.2
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(day_start) as date,
@@ -767,7 +1072,7 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.3
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.2
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature_flag_response'), '^"|"$', '') AS value,
@@ -785,7 +1090,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.4
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.3
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(day_start) as date,
@@ -847,19 +1152,69 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_out_of_timerange_timezone.4
   '''
-  /* user_id:0 celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  /* user_id:0 request:_snapshot_ */
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-06 07:00:00', 'US/Pacific')) - toIntervalDay(number) as day_start
+              FROM numbers(6)
+              UNION ALL SELECT toStartOfDay(toDateTime('2020-01-01 02:10:00', 'US/Pacific')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['control', 'test'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'US/Pacific')) as day_start,
+                            breakdown_value
+           FROM
+             (SELECT person_id,
+                     min(timestamp) as timestamp,
+                     breakdown_value
+              FROM
+                (SELECT pdi.person_id as person_id, timestamp, transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$feature_flag_response'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['control', 'test']), (['control', 'test']), '$$_posthog_breakdown_other_$$') as breakdown_value
+                 FROM events e
+                 INNER JOIN
+                   (SELECT distinct_id,
+                           argMax(person_id, version) as person_id
+                    FROM person_distinct_id2
+                    WHERE team_id = 99999
+                    GROUP BY distinct_id
+                    HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+                 WHERE e.team_id = 99999
+                   AND event = '$feature_flag_called'
+                   AND ((has(['control', 'test'], replaceRegexpAll(JSONExtractRaw(e.properties, '$feature_flag_response'), '^"|"$', '')))
+                        AND (has(['a-b-test'], replaceRegexpAll(JSONExtractRaw(e.properties, '$feature_flag'), '^"|"$', ''))))
+                   AND toTimeZone(timestamp, 'US/Pacific') >= toDateTime('2020-01-01 02:10:00', 'US/Pacific')
+                   AND toTimeZone(timestamp, 'US/Pacific') <= toDateTime('2020-01-06 07:00:00', 'US/Pacific') )
+              GROUP BY person_id,
+                       breakdown_value) AS pdi
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter.1
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature/a-b-test'), '^"|"$', '') AS value,
@@ -877,7 +1232,7 @@
   OFFSET 0
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter.2
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter.1
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(day_start) as date,
@@ -924,7 +1279,7 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter.3
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter.2
   '''
   /* user_id:0 request:_snapshot_ */
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$feature_flag_response'), '^"|"$', '') AS value,
@@ -942,6 +1297,68 @@
   OFFSET 0
   '''
 # ---
+# name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter.3
+  '''
+  /* user_id:0 request:_snapshot_ */
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-06 00:00:00', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(6)
+              UNION ALL SELECT toStartOfDay(toDateTime('2020-01-01 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['control', 'test'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            breakdown_value
+           FROM
+             (SELECT person_id,
+                     min(timestamp) as timestamp,
+                     breakdown_value
+              FROM
+                (SELECT pdi.person_id as person_id, timestamp, transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$feature_flag_response'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['control', 'test']), (['control', 'test']), '$$_posthog_breakdown_other_$$') as breakdown_value
+                 FROM events e
+                 INNER JOIN
+                   (SELECT distinct_id,
+                           argMax(person_id, version) as person_id
+                    FROM person_distinct_id2
+                    WHERE team_id = 99999
+                    GROUP BY distinct_id
+                    HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+                 WHERE e.team_id = 99999
+                   AND event = '$feature_flag_called'
+                   AND ((has(['control', 'test'], replaceRegexpAll(JSONExtractRaw(e.properties, '$feature_flag_response'), '^"|"$', '')))
+                        AND (has(['a-b-test'], replaceRegexpAll(JSONExtractRaw(e.properties, '$feature_flag'), '^"|"$', ''))))
+                   AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
+                   AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-06 00:00:00', 'UTC') )
+              GROUP BY person_id,
+                       breakdown_value) AS pdi
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
+  '''
+# ---
 # name: ClickhouseTestTrendExperimentResults.test_experiment_flow_with_event_results_with_hogql_filter.4
   '''
   /* user_id:0 request:_snapshot_ */
diff --git a/ee/clickhouse/views/test/test_clickhouse_experiments.py b/ee/clickhouse/views/test/test_clickhouse_experiments.py
index aa6d791c6d3d0..a4c8bf9f3eb13 100644
--- a/ee/clickhouse/views/test/test_clickhouse_experiments.py
+++ b/ee/clickhouse/views/test/test_clickhouse_experiments.py
@@ -1753,6 +1753,114 @@ def test_create_draft_experiment_without_filters(self) -> None:
         self.assertEqual(response.json()["name"], "Test Experiment")
         self.assertEqual(response.json()["feature_flag_key"], ff_key)
 
+    def test_feature_flag_and_experiment_sync(self):
+        # Create an experiment with control and test variants
+        response = self.client.post(
+            f"/api/projects/{self.team.id}/experiments/",
+            {
+                "name": "Test Experiment",
+                "description": "My test experiment",
+                "feature_flag_key": "experiment-test-flag",
+                "parameters": {
+                    "feature_flag_variants": [
+                        {"key": "control", "name": "Control Group", "rollout_percentage": 50},
+                        {"key": "test", "name": "Test Variant", "rollout_percentage": 50},
+                    ]
+                },
+                "filters": {"insight": "TRENDS", "events": [{"order": 0, "id": "$pageview"}]},
+            },
+        )
+
+        self.assertEqual(response.status_code, 201)
+        experiment_id = response.json()["id"]
+        feature_flag_id = response.json()["feature_flag"]["id"]
+
+        # Fetch the FeatureFlag object
+        feature_flag = FeatureFlag.objects.get(id=feature_flag_id)
+
+        variants = feature_flag.filters["multivariate"]["variants"]
+
+        # Verify that the variants are correctly populated
+        self.assertEqual(len(variants), 2)
+
+        self.assertEqual(variants[0]["key"], "control")
+        self.assertEqual(variants[0]["name"], "Control Group")
+        self.assertEqual(variants[0]["rollout_percentage"], 50)
+
+        self.assertEqual(variants[1]["key"], "test")
+        self.assertEqual(variants[1]["name"], "Test Variant")
+        self.assertEqual(variants[1]["rollout_percentage"], 50)
+
+        # Change the rollout percentages and groups of the feature flag
+        response = self.client.patch(
+            f"/api/projects/{self.team.id}/feature_flags/{feature_flag_id}",
+            {
+                "filters": {
+                    "groups": [
+                        {"properties": [], "rollout_percentage": 99},
+                        {"properties": [], "rollout_percentage": 1},
+                    ],
+                    "payloads": {},
+                    "multivariate": {
+                        "variants": [
+                            {"key": "control", "rollout_percentage": 10},
+                            {"key": "test", "rollout_percentage": 90},
+                        ]
+                    },
+                    "aggregation_group_type_index": 1,
+                }
+            },
+        )
+
+        # Verify that Experiment.parameters.feature_flag_variants reflects the updated FeatureFlag.filters.multivariate.variants
+        experiment = Experiment.objects.get(id=experiment_id)
+        self.assertEqual(
+            experiment.parameters["feature_flag_variants"],
+            [{"key": "control", "rollout_percentage": 10}, {"key": "test", "rollout_percentage": 90}],
+        )
+        self.assertEqual(experiment.parameters["aggregation_group_type_index"], 1)
+
+        # Update the experiment with an unrelated change
+        response = self.client.patch(
+            f"/api/projects/{self.team.id}/experiments/{experiment_id}",
+            {"name": "Updated Test Experiment"},
+        )
+
+        # Verify that the feature flag variants and groups remain unchanged
+        feature_flag = FeatureFlag.objects.get(id=feature_flag_id)
+        self.assertEqual(
+            feature_flag.filters["multivariate"]["variants"],
+            [{"key": "control", "rollout_percentage": 10}, {"key": "test", "rollout_percentage": 90}],
+        )
+        self.assertEqual(
+            feature_flag.filters["groups"],
+            [{"properties": [], "rollout_percentage": 99}, {"properties": [], "rollout_percentage": 1}],
+        )
+
+        # Test removing aggregation_group_type_index
+        response = self.client.patch(
+            f"/api/projects/{self.team.id}/feature_flags/{feature_flag_id}",
+            {
+                "filters": {
+                    "groups": [
+                        {"properties": [], "rollout_percentage": 99},
+                        {"properties": [], "rollout_percentage": 1},
+                    ],
+                    "payloads": {},
+                    "multivariate": {
+                        "variants": [
+                            {"key": "control", "rollout_percentage": 10},
+                            {"key": "test", "rollout_percentage": 90},
+                        ]
+                    },
+                }
+            },
+        )
+
+        # Verify that aggregation_group_type_index is removed from experiment parameters
+        experiment = Experiment.objects.get(id=experiment_id)
+        self.assertNotIn("aggregation_group_type_index", experiment.parameters)
+
 
 class TestExperimentAuxiliaryEndpoints(ClickhouseTestMixin, APILicensedTest):
     def _generate_experiment(self, start_date="2024-01-01T10:23", extra_parameters=None):
diff --git a/ee/clickhouse/views/test/test_clickhouse_path_person.py b/ee/clickhouse/views/test/test_clickhouse_path_person.py
index 48fc8a2475c06..597aa6dffc5e2 100644
--- a/ee/clickhouse/views/test/test_clickhouse_path_person.py
+++ b/ee/clickhouse/views/test/test_clickhouse_path_person.py
@@ -97,6 +97,7 @@ def test_create_paths_cohort(self, _insert_cohort_from_insight_filter):
                 "date_from": "2021-05-01",
                 "date_to": "2021-05-10",
             },
+            self.team.pk,
         )
 
         insert_cohort_from_insight_filter(cohort_id, params)
diff --git a/ee/hogai/assistant.py b/ee/hogai/assistant.py
index 77b1c2c050008..3a296ba9ce7d6 100644
--- a/ee/hogai/assistant.py
+++ b/ee/hogai/assistant.py
@@ -1,9 +1,12 @@
+import json
 from collections.abc import AsyncGenerator, Generator, Iterator
 from functools import partial
-from typing import Any, Literal, Optional, TypedDict, TypeGuard, Union
+from typing import Any, Optional
+from uuid import uuid4
 
 from asgiref.sync import sync_to_async
 from langchain_core.messages import AIMessageChunk
+from langchain_core.runnables.config import RunnableConfig
 from langfuse.callback import CallbackHandler
 from langgraph.graph.state import CompiledStateGraph
 from pydantic import BaseModel
@@ -17,7 +20,19 @@
 from ee.hogai.trends.nodes import (
     TrendsGeneratorNode,
 )
-from ee.hogai.utils import AssistantNodeName, AssistantState, Conversation
+from ee.hogai.utils.state import (
+    GraphMessageUpdateTuple,
+    GraphTaskStartedUpdateTuple,
+    GraphValueUpdateTuple,
+    is_message_update,
+    is_state_update,
+    is_task_started_update,
+    is_value_update,
+    validate_state_update,
+    validate_value_update,
+)
+from ee.hogai.utils.types import AssistantNodeName, AssistantState, PartialAssistantState
+from ee.models import Conversation
 from posthog.event_usage import report_user_action
 from posthog.models import Team, User
 from posthog.schema import (
@@ -40,42 +55,6 @@
     langfuse_handler = None
 
 
-def is_value_update(update: list[Any]) -> TypeGuard[tuple[Literal["values"], dict[AssistantNodeName, AssistantState]]]:
-    """
-    Transition between nodes.
-    """
-    return len(update) == 2 and update[0] == "updates"
-
-
-class LangGraphState(TypedDict):
-    langgraph_node: AssistantNodeName
-
-
-def is_message_update(
-    update: list[Any],
-) -> TypeGuard[tuple[Literal["messages"], tuple[Union[AIMessageChunk, Any], LangGraphState]]]:
-    """
-    Streaming of messages. Returns a partial state.
-    """
-    return len(update) == 2 and update[0] == "messages"
-
-
-def is_state_update(update: list[Any]) -> TypeGuard[tuple[Literal["updates"], AssistantState]]:
-    """
-    Update of the state.
-    """
-    return len(update) == 2 and update[0] == "values"
-
-
-def is_task_started_update(
-    update: list[Any],
-) -> TypeGuard[tuple[Literal["messages"], tuple[Union[AIMessageChunk, Any], LangGraphState]]]:
-    """
-    Streaming of messages. Returns a partial state.
-    """
-    return len(update) == 2 and update[0] == "debug" and update[1]["type"] == "task"
-
-
 VISUALIZATION_NODES: dict[AssistantNodeName, type[SchemaGeneratorNode]] = {
     AssistantNodeName.TRENDS_GENERATOR: TrendsGeneratorNode,
     AssistantNodeName.FUNNEL_GENERATOR: FunnelGeneratorNode,
@@ -87,13 +66,25 @@ class Assistant:
     _graph: CompiledStateGraph
     _user: Optional[User]
     _conversation: Conversation
+    _latest_message: HumanMessage
+    _state: Optional[AssistantState]
 
-    def __init__(self, team: Team, conversation: Conversation, user: Optional[User] = None):
+    def __init__(
+        self,
+        team: Team,
+        conversation: Conversation,
+        new_message: HumanMessage,
+        user: Optional[User] = None,
+        is_new_conversation: bool = False,
+    ):
         self._team = team
         self._user = user
         self._conversation = conversation
+        self._latest_message = new_message.model_copy(deep=True, update={"id": str(uuid4())})
+        self._is_new_conversation = is_new_conversation
         self._graph = AssistantGraph(team).compile_full_graph()
         self._chunks = AIMessageChunk(content="")
+        self._state = None
 
     def stream(self):
         if SERVER_GATEWAY_INTERFACE == "ASGI":
@@ -110,15 +101,19 @@ async def _astream(self) -> AsyncGenerator[str, None]:
                 break
 
     def _stream(self) -> Generator[str, None, None]:
-        callbacks = [langfuse_handler] if langfuse_handler else []
+        state = self._init_or_update_state()
+        config = self._get_config()
+
         generator: Iterator[Any] = self._graph.stream(
-            self._initial_state,
-            config={"recursion_limit": 24, "callbacks": callbacks},
-            stream_mode=["messages", "values", "updates", "debug"],
+            state, config=config, stream_mode=["messages", "values", "updates", "debug"]
         )
 
-        # Send a chunk to establish the connection avoiding the worker's timeout.
-        yield self._serialize_message(AssistantGenerationStatusEvent(type=AssistantGenerationStatusType.ACK))
+        # Assign the conversation id to the client.
+        if self._is_new_conversation:
+            yield self._serialize_conversation()
+
+        # Send the last message with the initialized id.
+        yield self._serialize_message(self._latest_message)
 
         try:
             last_viz_message = None
@@ -127,7 +122,15 @@ def _stream(self) -> Generator[str, None, None]:
                     if isinstance(message, VisualizationMessage):
                         last_viz_message = message
                     yield self._serialize_message(message)
-            self._report_conversation(last_viz_message)
+
+            # Check if the assistant has requested help.
+            state = self._graph.get_state(config)
+            if state.next:
+                yield self._serialize_message(
+                    AssistantMessage(content=state.tasks[0].interrupts[0].value, id=str(uuid4()))
+                )
+            else:
+                self._report_conversation_state(last_viz_message)
         except:
             # This is an unhandled error, so we just stop further generation at this point
             yield self._serialize_message(FailureMessage())
@@ -135,8 +138,34 @@ def _stream(self) -> Generator[str, None, None]:
 
     @property
     def _initial_state(self) -> AssistantState:
-        messages = [message.root for message in self._conversation.messages]
-        return {"messages": messages, "intermediate_steps": None, "plan": None}
+        return AssistantState(messages=[self._latest_message], start_id=self._latest_message.id)
+
+    def _get_config(self) -> RunnableConfig:
+        callbacks = [langfuse_handler] if langfuse_handler else []
+        config: RunnableConfig = {
+            "recursion_limit": 24,
+            "callbacks": callbacks,
+            "configurable": {"thread_id": self._conversation.id},
+        }
+        return config
+
+    def _init_or_update_state(self):
+        config = self._get_config()
+        snapshot = self._graph.get_state(config)
+        if snapshot.next:
+            saved_state = validate_state_update(snapshot.values)
+            self._state = saved_state
+            if saved_state.intermediate_steps:
+                intermediate_steps = saved_state.intermediate_steps.copy()
+                intermediate_steps[-1] = (intermediate_steps[-1][0], self._latest_message.content)
+                self._graph.update_state(
+                    config,
+                    PartialAssistantState(messages=[self._latest_message], intermediate_steps=intermediate_steps),
+                )
+            return None
+        initial_state = self._initial_state
+        self._state = initial_state
+        return initial_state
 
     def _node_to_reasoning_message(
         self, node_name: AssistantNodeName, input: AssistantState
@@ -152,7 +181,7 @@ def _node_to_reasoning_message(
             ):
                 substeps: list[str] = []
                 if input:
-                    if intermediate_steps := input.get("intermediate_steps"):
+                    if intermediate_steps := input.intermediate_steps:
                         for action, _ in intermediate_steps:
                             match action.tool:
                                 case "retrieve_event_properties":
@@ -178,42 +207,65 @@ def _node_to_reasoning_message(
                 return None
 
     def _process_update(self, update: Any) -> BaseModel | None:
-        if is_value_update(update):
-            _, state_update = update
+        if is_state_update(update):
+            _, new_state = update
+            self._state = validate_state_update(new_state)
+        elif is_value_update(update) and (new_message := self._process_value_update(update)):
+            return new_message
+        elif is_message_update(update) and (new_message := self._process_message_update(update)):
+            return new_message
+        elif is_task_started_update(update) and (new_message := self._process_task_started_update(update)):
+            return new_message
+        return None
 
-            if AssistantNodeName.ROUTER in state_update and "messages" in state_update[AssistantNodeName.ROUTER]:
-                return state_update[AssistantNodeName.ROUTER]["messages"][0]
-            elif intersected_nodes := state_update.keys() & VISUALIZATION_NODES.keys():
-                # Reset chunks when schema validation fails.
-                self._chunks = AIMessageChunk(content="")
+    def _process_value_update(self, update: GraphValueUpdateTuple) -> BaseModel | None:
+        _, maybe_state_update = update
+        state_update = validate_value_update(maybe_state_update)
+
+        if node_val := state_update.get(AssistantNodeName.ROUTER):
+            if isinstance(node_val, PartialAssistantState) and node_val.messages:
+                return node_val.messages[0]
+        elif intersected_nodes := state_update.keys() & VISUALIZATION_NODES.keys():
+            # Reset chunks when schema validation fails.
+            self._chunks = AIMessageChunk(content="")
 
-                node_name = intersected_nodes.pop()
-                if "messages" in state_update[node_name]:
-                    return state_update[node_name]["messages"][0]
-                elif state_update[node_name].get("intermediate_steps", []):
-                    return AssistantGenerationStatusEvent(type=AssistantGenerationStatusType.GENERATION_ERROR)
-            elif AssistantNodeName.SUMMARIZER in state_update:
+            node_name = intersected_nodes.pop()
+            node_val = state_update[node_name]
+            if not isinstance(node_val, PartialAssistantState):
+                return None
+            if node_val.messages:
+                return node_val.messages[0]
+            elif node_val.intermediate_steps:
+                return AssistantGenerationStatusEvent(type=AssistantGenerationStatusType.GENERATION_ERROR)
+        elif node_val := state_update.get(AssistantNodeName.SUMMARIZER):
+            if isinstance(node_val, PartialAssistantState) and node_val.messages:
                 self._chunks = AIMessageChunk(content="")
-                return state_update[AssistantNodeName.SUMMARIZER]["messages"][0]
-        elif is_message_update(update):
-            langchain_message, langgraph_state = update[1]
-            if isinstance(langchain_message, AIMessageChunk):
-                if langgraph_state["langgraph_node"] in VISUALIZATION_NODES.keys():
-                    self._chunks += langchain_message  # type: ignore
-                    parsed_message = VISUALIZATION_NODES[langgraph_state["langgraph_node"]].parse_output(
-                        self._chunks.tool_calls[0]["args"]
-                    )
-                    if parsed_message:
-                        return VisualizationMessage(answer=parsed_message.query)
-                elif langgraph_state["langgraph_node"] == AssistantNodeName.SUMMARIZER:
-                    self._chunks += langchain_message  # type: ignore
-                    return AssistantMessage(content=self._chunks.content)
-        elif is_task_started_update(update):
-            _, task_update = update
-            node_name = task_update["payload"]["name"]  # type: ignore
-            node_input = task_update["payload"]["input"]  # type: ignore
-            if reasoning_message := self._node_to_reasoning_message(node_name, node_input):
-                return reasoning_message
+                return node_val.messages[0]
+
+        return None
+
+    def _process_message_update(self, update: GraphMessageUpdateTuple) -> BaseModel | None:
+        langchain_message, langgraph_state = update[1]
+        if isinstance(langchain_message, AIMessageChunk):
+            if langgraph_state["langgraph_node"] in VISUALIZATION_NODES.keys():
+                self._chunks += langchain_message  # type: ignore
+                parsed_message = VISUALIZATION_NODES[langgraph_state["langgraph_node"]].parse_output(
+                    self._chunks.tool_calls[0]["args"]
+                )
+                if parsed_message:
+                    initiator_id = self._state.start_id if self._state is not None else None
+                    return VisualizationMessage(answer=parsed_message.query, initiator=initiator_id)
+            elif langgraph_state["langgraph_node"] == AssistantNodeName.SUMMARIZER:
+                self._chunks += langchain_message  # type: ignore
+                return AssistantMessage(content=self._chunks.content)
+        return None
+
+    def _process_task_started_update(self, update: GraphTaskStartedUpdateTuple) -> BaseModel | None:
+        _, task_update = update
+        node_name = task_update["payload"]["name"]  # type: ignore
+        node_input = task_update["payload"]["input"]  # type: ignore
+        if reasoning_message := self._node_to_reasoning_message(node_name, node_input):
+            return reasoning_message
         return None
 
     def _serialize_message(self, message: BaseModel) -> str:
@@ -224,9 +276,15 @@ def _serialize_message(self, message: BaseModel) -> str:
             output += f"event: {AssistantEventType.MESSAGE}\n"
         return output + f"data: {message.model_dump_json(exclude_none=True)}\n\n"
 
-    def _report_conversation(self, message: Optional[VisualizationMessage]):
-        human_message = self._conversation.messages[-1].root
-        if self._user and message and isinstance(human_message, HumanMessage):
+    def _serialize_conversation(self) -> str:
+        output = f"event: {AssistantEventType.CONVERSATION}\n"
+        json_conversation = json.dumps({"id": str(self._conversation.id)})
+        output += f"data: {json_conversation}\n\n"
+        return output
+
+    def _report_conversation_state(self, message: Optional[VisualizationMessage]):
+        human_message = self._latest_message
+        if self._user and message:
             report_user_action(
                 self._user,
                 "chat with ai",
diff --git a/ee/hogai/django_checkpoint/__init__.py b/ee/hogai/django_checkpoint/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/ee/hogai/django_checkpoint/checkpointer.py b/ee/hogai/django_checkpoint/checkpointer.py
new file mode 100644
index 0000000000000..78817dca9df76
--- /dev/null
+++ b/ee/hogai/django_checkpoint/checkpointer.py
@@ -0,0 +1,309 @@
+import json
+import random
+import threading
+from collections.abc import Iterable, Iterator, Sequence
+from typing import Any, Optional, cast
+
+from django.db import transaction
+from django.db.models import Q
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import (
+    WRITES_IDX_MAP,
+    BaseCheckpointSaver,
+    ChannelVersions,
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+    PendingWrite,
+    get_checkpoint_id,
+)
+from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+from langgraph.checkpoint.serde.types import ChannelProtocol
+
+from ee.models.assistant import ConversationCheckpoint, ConversationCheckpointBlob, ConversationCheckpointWrite
+
+
+class DjangoCheckpointer(BaseCheckpointSaver[str]):
+    jsonplus_serde = JsonPlusSerializer()
+    _lock: threading.Lock
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self._lock = threading.Lock()
+
+    def _load_writes(self, writes: Sequence[ConversationCheckpointWrite]) -> list[PendingWrite]:
+        return (
+            [
+                (
+                    str(checkpoint_write.task_id),
+                    checkpoint_write.channel,
+                    self.serde.loads_typed((checkpoint_write.type, checkpoint_write.blob)),
+                )
+                for checkpoint_write in writes
+                if checkpoint_write.type is not None and checkpoint_write.blob is not None
+            ]
+            if writes
+            else []
+        )
+
+    def _load_json(self, obj: Any):
+        return self.jsonplus_serde.loads(self.jsonplus_serde.dumps(obj))
+
+    def _dump_json(self, obj: Any) -> dict[str, Any]:
+        serialized_metadata = self.jsonplus_serde.dumps(obj)
+        # NOTE: we're using JSON serializer (not msgpack), so we need to remove null characters before writing
+        nulls_removed = serialized_metadata.decode().replace("\\u0000", "")
+        return json.loads(nulls_removed)
+
+    def _get_checkpoint_qs(
+        self,
+        config: Optional[RunnableConfig],
+        filter: Optional[dict[str, Any]],
+        before: Optional[RunnableConfig],
+    ):
+        query = Q()
+
+        # construct predicate for config filter
+        if config and "configurable" in config:
+            thread_id = config["configurable"].get("thread_id")
+            query &= Q(thread_id=thread_id)
+            checkpoint_ns = config["configurable"].get("checkpoint_ns")
+            if checkpoint_ns is not None:
+                query &= Q(checkpoint_ns=checkpoint_ns)
+            if checkpoint_id := get_checkpoint_id(config):
+                query &= Q(id=checkpoint_id)
+
+        # construct predicate for metadata filter
+        if filter:
+            query &= Q(metadata__contains=filter)
+
+        # construct predicate for `before`
+        if before is not None:
+            query &= Q(id__lt=get_checkpoint_id(before))
+
+        return ConversationCheckpoint.objects.filter(query).order_by("-id")
+
+    def _get_checkpoint_channel_values(
+        self, checkpoint: ConversationCheckpoint
+    ) -> Iterable[ConversationCheckpointBlob]:
+        if not checkpoint.checkpoint:
+            return []
+        loaded_checkpoint = self._load_json(checkpoint.checkpoint)
+        if "channel_versions" not in loaded_checkpoint:
+            return []
+        query = Q()
+        for channel, version in loaded_checkpoint["channel_versions"].items():
+            query |= Q(channel=channel, version=version)
+        return checkpoint.blobs.filter(query)
+
+    def list(
+        self,
+        config: Optional[RunnableConfig],
+        *,
+        filter: Optional[dict[str, Any]] = None,
+        before: Optional[RunnableConfig] = None,
+        limit: Optional[int] = None,
+    ) -> Iterator[CheckpointTuple]:
+        """List checkpoints from the database.
+
+        This method retrieves a list of checkpoint tuples from the Postgres database based
+        on the provided config. The checkpoints are ordered by checkpoint ID in descending order (newest first).
+
+        Args:
+            config (RunnableConfig): The config to use for listing the checkpoints.
+            filter (Optional[Dict[str, Any]]): Additional filtering criteria for metadata. Defaults to None.
+            before (Optional[RunnableConfig]): If provided, only checkpoints before the specified checkpoint ID are returned. Defaults to None.
+            limit (Optional[int]): The maximum number of checkpoints to return. Defaults to None.
+
+        Yields:
+            Iterator[CheckpointTuple]: An iterator of checkpoint tuples.
+        """
+        qs = self._get_checkpoint_qs(config, filter, before)
+        if limit:
+            qs = qs[:limit]
+
+        for checkpoint in qs:
+            channel_values = self._get_checkpoint_channel_values(checkpoint)
+            loaded_checkpoint: Checkpoint = self._load_json(checkpoint.checkpoint)
+
+            checkpoint_dict: Checkpoint = {
+                **loaded_checkpoint,
+                "pending_sends": [
+                    self.serde.loads_typed((checkpoint_write.type, checkpoint_write.blob))
+                    for checkpoint_write in checkpoint.pending_sends
+                ],
+                "channel_values": {
+                    checkpoint_blob.channel: self.serde.loads_typed((checkpoint_blob.type, checkpoint_blob.blob))
+                    for checkpoint_blob in channel_values
+                    if checkpoint_blob.type is not None
+                    and checkpoint_blob.type != "empty"
+                    and checkpoint_blob.blob is not None
+                },
+            }
+
+            yield CheckpointTuple(
+                {
+                    "configurable": {
+                        "thread_id": checkpoint.thread_id,
+                        "checkpoint_ns": checkpoint.checkpoint_ns,
+                        "checkpoint_id": checkpoint.id,
+                    }
+                },
+                checkpoint_dict,
+                self._load_json(checkpoint.metadata),
+                (
+                    {
+                        "configurable": {
+                            "thread_id": checkpoint.thread_id,
+                            "checkpoint_ns": checkpoint.checkpoint_ns,
+                            "checkpoint_id": checkpoint.parent_checkpoint_id,
+                        }
+                    }
+                    if checkpoint.parent_checkpoint
+                    else None
+                ),
+                self._load_writes(checkpoint.pending_writes),
+            )
+
+    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        """Get a checkpoint tuple from the database.
+
+        This method retrieves a checkpoint tuple from the Postgres database based on the
+        provided config. If the config contains a "checkpoint_id" key, the checkpoint with
+        the matching thread ID and timestamp is retrieved. Otherwise, the latest checkpoint
+        for the given thread ID is retrieved.
+
+        Args:
+            config (RunnableConfig): The config to use for retrieving the checkpoint.
+
+        Returns:
+            Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
+        """
+        return next(self.list(config), None)
+
+    def put(
+        self,
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: ChannelVersions,
+    ) -> RunnableConfig:
+        """Save a checkpoint to the database.
+
+        This method saves a checkpoint to the Postgres database. The checkpoint is associated
+        with the provided config and its parent config (if any).
+
+        Args:
+            config (RunnableConfig): The config to associate with the checkpoint.
+            checkpoint (Checkpoint): The checkpoint to save.
+            metadata (CheckpointMetadata): Additional metadata to save with the checkpoint.
+            new_versions (ChannelVersions): New channel versions as of this write.
+
+        Returns:
+            RunnableConfig: Updated configuration after storing the checkpoint.
+        """
+        configurable = config["configurable"]
+        thread_id: str = configurable["thread_id"]
+        checkpoint_id = get_checkpoint_id(config)
+        checkpoint_ns: str | None = configurable.get("checkpoint_ns") or ""
+
+        checkpoint_copy = cast(dict[str, Any], checkpoint.copy())
+        channel_values = checkpoint_copy.pop("channel_values", {})
+
+        next_config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint["id"],
+            }
+        }
+
+        with self._lock, transaction.atomic():
+            updated_checkpoint, _ = ConversationCheckpoint.objects.update_or_create(
+                id=checkpoint["id"],
+                thread_id=thread_id,
+                checkpoint_ns=checkpoint_ns,
+                defaults={
+                    "parent_checkpoint_id": checkpoint_id,
+                    "checkpoint": self._dump_json({**checkpoint_copy, "pending_sends": []}),
+                    "metadata": self._dump_json(metadata),
+                },
+            )
+
+            blobs = []
+            for channel, version in new_versions.items():
+                type, blob = (
+                    self.serde.dumps_typed(channel_values[channel]) if channel in channel_values else ("empty", None)
+                )
+                blobs.append(
+                    ConversationCheckpointBlob(
+                        checkpoint=updated_checkpoint,
+                        channel=channel,
+                        version=str(version),
+                        type=type,
+                        blob=blob,
+                    )
+                )
+
+            ConversationCheckpointBlob.objects.bulk_create(blobs, ignore_conflicts=True)
+        return next_config
+
+    def put_writes(
+        self,
+        config: RunnableConfig,
+        writes: Sequence[tuple[str, Any]],
+        task_id: str,
+    ) -> None:
+        """Store intermediate writes linked to a checkpoint.
+
+        This method saves intermediate writes associated with a checkpoint to the Postgres database.
+
+        Args:
+            config (RunnableConfig): Configuration of the related checkpoint.
+            writes (List[Tuple[str, Any]]): List of writes to store.
+            task_id (str): Identifier for the task creating the writes.
+        """
+        configurable = config["configurable"]
+        thread_id: str = configurable["thread_id"]
+        checkpoint_id = get_checkpoint_id(config)
+        checkpoint_ns: str | None = configurable.get("checkpoint_ns") or ""
+
+        with self._lock, transaction.atomic():
+            # `put_writes` and `put` are concurrently called without guaranteeing the call order
+            # so we need to ensure the checkpoint is created before creating writes.
+            # Thread.lock() will prevent race conditions though to the same checkpoints within a single pod.
+            checkpoint, _ = ConversationCheckpoint.objects.get_or_create(
+                id=checkpoint_id, thread_id=thread_id, checkpoint_ns=checkpoint_ns
+            )
+
+            writes_to_create = []
+            for idx, (channel, value) in enumerate(writes):
+                type, blob = self.serde.dumps_typed(value)
+                writes_to_create.append(
+                    ConversationCheckpointWrite(
+                        checkpoint=checkpoint,
+                        task_id=task_id,
+                        idx=idx,
+                        channel=channel,
+                        type=type,
+                        blob=blob,
+                    )
+                )
+
+            ConversationCheckpointWrite.objects.bulk_create(
+                writes_to_create,
+                update_conflicts=all(w[0] in WRITES_IDX_MAP for w in writes),
+                unique_fields=["checkpoint", "task_id", "idx"],
+                update_fields=["channel", "type", "blob"],
+            )
+
+    def get_next_version(self, current: Optional[str | int], channel: ChannelProtocol) -> str:
+        if current is None:
+            current_v = 0
+        elif isinstance(current, int):
+            current_v = current
+        else:
+            current_v = int(current.split(".")[0])
+        next_v = current_v + 1
+        next_h = random.random()
+        return f"{next_v:032}.{next_h:016}"
diff --git a/ee/hogai/django_checkpoint/test/test_checkpointer.py b/ee/hogai/django_checkpoint/test/test_checkpointer.py
new file mode 100644
index 0000000000000..2f8fd7f4a60ed
--- /dev/null
+++ b/ee/hogai/django_checkpoint/test/test_checkpointer.py
@@ -0,0 +1,274 @@
+# type: ignore
+
+from typing import Any, TypedDict
+
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import (
+    Checkpoint,
+    CheckpointMetadata,
+    create_checkpoint,
+    empty_checkpoint,
+)
+from langgraph.checkpoint.base.id import uuid6
+from langgraph.errors import NodeInterrupt
+from langgraph.graph import END, START
+from langgraph.graph.state import CompiledStateGraph, StateGraph
+
+from ee.hogai.django_checkpoint.checkpointer import DjangoCheckpointer
+from ee.models.assistant import (
+    Conversation,
+    ConversationCheckpoint,
+    ConversationCheckpointBlob,
+    ConversationCheckpointWrite,
+)
+from posthog.test.base import NonAtomicBaseTest
+
+
+class TestDjangoCheckpointer(NonAtomicBaseTest):
+    CLASS_DATA_LEVEL_SETUP = False
+
+    def _build_graph(self, checkpointer: DjangoCheckpointer):
+        class State(TypedDict):
+            val: int
+
+        graph = StateGraph(State)
+
+        def handle_node1(state: State) -> State:
+            if state["val"] == 1:
+                raise NodeInterrupt("test")
+            return {"val": state["val"] + 1}
+
+        graph.add_node("node1", handle_node1)
+        graph.add_node("node2", lambda state: state)
+
+        graph.add_edge(START, "node1")
+        graph.add_edge("node1", "node2")
+        graph.add_edge("node2", END)
+
+        return graph.compile(checkpointer=checkpointer)
+
+    def test_saver(self):
+        thread1 = Conversation.objects.create(user=self.user, team=self.team)
+        thread2 = Conversation.objects.create(user=self.user, team=self.team)
+
+        config_1: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread1.id,
+                "checkpoint_ns": "",
+            }
+        }
+        chkpnt_1: Checkpoint = empty_checkpoint()
+
+        config_2: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread2.id,
+                "checkpoint_ns": "",
+            }
+        }
+        chkpnt_2: Checkpoint = create_checkpoint(chkpnt_1, {}, 1)
+
+        config_3: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread2.id,
+                "checkpoint_id": chkpnt_2["id"],
+                "checkpoint_ns": "inner",
+            }
+        }
+        chkpnt_3: Checkpoint = empty_checkpoint()
+
+        metadata_1: CheckpointMetadata = {
+            "source": "input",
+            "step": 2,
+            "writes": {},
+            "score": 1,
+        }
+        metadata_2: CheckpointMetadata = {
+            "source": "loop",
+            "step": 1,
+            "writes": {"foo": "bar"},
+            "score": None,
+        }
+        metadata_3: CheckpointMetadata = {}
+
+        test_data = {
+            "configs": [config_1, config_2, config_3],
+            "checkpoints": [chkpnt_1, chkpnt_2, chkpnt_3],
+            "metadata": [metadata_1, metadata_2, metadata_3],
+        }
+
+        saver = DjangoCheckpointer()
+
+        configs = test_data["configs"]
+        checkpoints = test_data["checkpoints"]
+        metadata = test_data["metadata"]
+
+        saver.put(configs[0], checkpoints[0], metadata[0], {})
+        saver.put(configs[1], checkpoints[1], metadata[1], {})
+        saver.put(configs[2], checkpoints[2], metadata[2], {})
+
+        # call method / assertions
+        query_1 = {"source": "input"}  # search by 1 key
+        query_2 = {
+            "step": 1,
+            "writes": {"foo": "bar"},
+        }  # search by multiple keys
+        query_3: dict[str, Any] = {}  # search by no keys, return all checkpoints
+        query_4 = {"source": "update", "step": 1}  # no match
+
+        search_results_1 = list(saver.list(None, filter=query_1))
+        assert len(search_results_1) == 1
+        assert search_results_1[0].metadata == metadata[0]
+
+        search_results_2 = list(saver.list(None, filter=query_2))
+        assert len(search_results_2) == 1
+        assert search_results_2[0].metadata == metadata[1]
+
+        search_results_3 = list(saver.list(None, filter=query_3))
+        assert len(search_results_3) == 3
+
+        search_results_4 = list(saver.list(None, filter=query_4))
+        assert len(search_results_4) == 0
+
+        # search by config (defaults to checkpoints across all namespaces)
+        search_results_5 = list(saver.list({"configurable": {"thread_id": thread2.id}}))
+        assert len(search_results_5) == 2
+        assert {
+            search_results_5[0].config["configurable"]["checkpoint_ns"],
+            search_results_5[1].config["configurable"]["checkpoint_ns"],
+        } == {"", "inner"}
+
+    def test_channel_versions(self):
+        thread1 = Conversation.objects.create(user=self.user, team=self.team)
+
+        chkpnt = {
+            "v": 1,
+            "ts": "2024-07-31T20:14:19.804150+00:00",
+            "id": str(uuid6(clock_seq=-2)),
+            "channel_values": {
+                "post": "hog",
+                "node": "node",
+            },
+            "channel_versions": {
+                "__start__": 2,
+                "my_key": 3,
+                "start:node": 3,
+                "node": 3,
+            },
+            "versions_seen": {
+                "__input__": {},
+                "__start__": {"__start__": 1},
+                "node": {"start:node": 2},
+            },
+            "pending_sends": [],
+        }
+        metadata = {"meta": "key"}
+
+        write_config = {"configurable": {"thread_id": thread1.id, "checkpoint_ns": ""}}
+        read_config = {"configurable": {"thread_id": thread1.id}}
+
+        saver = DjangoCheckpointer()
+        saver.put(write_config, chkpnt, metadata, {})
+
+        checkpoint = ConversationCheckpoint.objects.first()
+        self.assertIsNotNone(checkpoint)
+        self.assertEqual(checkpoint.thread, thread1)
+        self.assertEqual(checkpoint.checkpoint_ns, "")
+        self.assertEqual(str(checkpoint.id), chkpnt["id"])
+        self.assertIsNone(checkpoint.parent_checkpoint)
+        chkpnt.pop("channel_values")
+        self.assertEqual(checkpoint.checkpoint, chkpnt)
+        self.assertEqual(checkpoint.metadata, metadata)
+
+        checkpoints = list(saver.list(read_config))
+        self.assertEqual(len(checkpoints), 1)
+
+        checkpoint = saver.get(read_config)
+        self.assertEqual(checkpoint, checkpoints[0].checkpoint)
+
+    def test_put_copies_checkpoint(self):
+        thread1 = Conversation.objects.create(user=self.user, team=self.team)
+        chkpnt = {
+            "v": 1,
+            "ts": "2024-07-31T20:14:19.804150+00:00",
+            "id": str(uuid6(clock_seq=-2)),
+            "channel_values": {
+                "post": "hog",
+                "node": "node",
+            },
+            "channel_versions": {
+                "__start__": 2,
+                "my_key": 3,
+                "start:node": 3,
+                "node": 3,
+            },
+            "versions_seen": {
+                "__input__": {},
+                "__start__": {"__start__": 1},
+                "node": {"start:node": 2},
+            },
+            "pending_sends": [],
+        }
+        metadata = {"meta": "key"}
+        write_config = {"configurable": {"thread_id": thread1.id, "checkpoint_ns": ""}}
+        saver = DjangoCheckpointer()
+        saver.put(write_config, chkpnt, metadata, {})
+        self.assertIn("channel_values", chkpnt)
+
+    def test_concurrent_puts_and_put_writes(self):
+        graph: CompiledStateGraph = self._build_graph(DjangoCheckpointer())
+        thread = Conversation.objects.create(user=self.user, team=self.team)
+        config = {"configurable": {"thread_id": str(thread.id)}}
+        graph.invoke(
+            {"val": 0},
+            config=config,
+        )
+        self.assertEqual(len(ConversationCheckpoint.objects.all()), 4)
+        self.assertEqual(len(ConversationCheckpointBlob.objects.all()), 10)
+        self.assertEqual(len(ConversationCheckpointWrite.objects.all()), 6)
+
+    def test_resuming(self):
+        checkpointer = DjangoCheckpointer()
+        graph: CompiledStateGraph = self._build_graph(checkpointer)
+        thread = Conversation.objects.create(user=self.user, team=self.team)
+        config = {"configurable": {"thread_id": str(thread.id)}}
+
+        graph.invoke(
+            {"val": 1},
+            config=config,
+        )
+        snapshot = graph.get_state(config)
+        self.assertIsNotNone(snapshot.next)
+        self.assertEqual(snapshot.tasks[0].interrupts[0].value, "test")
+
+        self.assertEqual(len(ConversationCheckpoint.objects.all()), 2)
+        self.assertEqual(len(ConversationCheckpointBlob.objects.all()), 4)
+        self.assertEqual(len(ConversationCheckpointWrite.objects.all()), 3)
+        self.assertEqual(len(list(checkpointer.list(config))), 2)
+
+        latest_checkpoint = ConversationCheckpoint.objects.last()
+        latest_write = ConversationCheckpointWrite.objects.filter(checkpoint=latest_checkpoint).first()
+        actual_checkpoint = checkpointer.get_tuple(config)
+        self.assertIsNotNone(actual_checkpoint)
+        self.assertIsNotNone(latest_write)
+        self.assertEqual(len(latest_checkpoint.writes.all()), 1)
+        blobs = list(latest_checkpoint.blobs.all())
+        self.assertEqual(len(blobs), 3)
+        self.assertEqual(actual_checkpoint.checkpoint["id"], str(latest_checkpoint.id))
+        self.assertEqual(len(actual_checkpoint.pending_writes), 1)
+        self.assertEqual(actual_checkpoint.pending_writes[0][0], str(latest_write.task_id))
+
+        graph.update_state(config, {"val": 2})
+        # add the value update checkpoint
+        self.assertEqual(len(ConversationCheckpoint.objects.all()), 3)
+        self.assertEqual(len(ConversationCheckpointBlob.objects.all()), 6)
+        self.assertEqual(len(ConversationCheckpointWrite.objects.all()), 5)
+        self.assertEqual(len(list(checkpointer.list(config))), 3)
+
+        res = graph.invoke(None, config=config)
+        self.assertEqual(len(ConversationCheckpoint.objects.all()), 5)
+        self.assertEqual(len(ConversationCheckpointBlob.objects.all()), 12)
+        self.assertEqual(len(ConversationCheckpointWrite.objects.all()), 9)
+        self.assertEqual(len(list(checkpointer.list(config))), 5)
+        self.assertEqual(res, {"val": 3})
+        snapshot = graph.get_state(config)
+        self.assertFalse(snapshot.next)
diff --git a/ee/hogai/eval/tests/test_eval_funnel_generator.py b/ee/hogai/eval/tests/test_eval_funnel_generator.py
index cd7e93b260ae9..4d7876ca6f73c 100644
--- a/ee/hogai/eval/tests/test_eval_funnel_generator.py
+++ b/ee/hogai/eval/tests/test_eval_funnel_generator.py
@@ -1,9 +1,11 @@
+from typing import cast
+
 from langgraph.graph.state import CompiledStateGraph
 
 from ee.hogai.assistant import AssistantGraph
 from ee.hogai.eval.utils import EvalBaseTest
-from ee.hogai.utils import AssistantNodeName
-from posthog.schema import AssistantFunnelsQuery, HumanMessage
+from ee.hogai.utils.types import AssistantNodeName, AssistantState
+from posthog.schema import AssistantFunnelsQuery, HumanMessage, VisualizationMessage
 
 
 class TestEvalFunnelGenerator(EvalBaseTest):
@@ -14,8 +16,11 @@ def _call_node(self, query: str, plan: str) -> AssistantFunnelsQuery:
             .add_funnel_generator(AssistantNodeName.END)
             .compile()
         )
-        state = graph.invoke({"messages": [HumanMessage(content=query)], "plan": plan})
-        return state["messages"][-1].answer
+        state = graph.invoke(
+            AssistantState(messages=[HumanMessage(content=query)], plan=plan),
+            self._get_config(),
+        )
+        return cast(VisualizationMessage, AssistantState.model_validate(state).messages[-1]).answer
 
     def test_node_replaces_equals_with_contains(self):
         query = "what is the conversion rate from a page view to sign up for users with name John?"
diff --git a/ee/hogai/eval/tests/test_eval_funnel_planner.py b/ee/hogai/eval/tests/test_eval_funnel_planner.py
index 3760961f9bb03..9adbd75e77c6c 100644
--- a/ee/hogai/eval/tests/test_eval_funnel_planner.py
+++ b/ee/hogai/eval/tests/test_eval_funnel_planner.py
@@ -5,7 +5,7 @@
 
 from ee.hogai.assistant import AssistantGraph
 from ee.hogai.eval.utils import EvalBaseTest
-from ee.hogai.utils import AssistantNodeName
+from ee.hogai.utils.types import AssistantNodeName, AssistantState
 from posthog.schema import HumanMessage
 
 
@@ -40,8 +40,11 @@ def _call_node(self, query):
             .add_funnel_planner(AssistantNodeName.END)
             .compile()
         )
-        state = graph.invoke({"messages": [HumanMessage(content=query)]})
-        return state["plan"]
+        state = graph.invoke(
+            AssistantState(messages=[HumanMessage(content=query)]),
+            self._get_config(),
+        )
+        return AssistantState.model_validate(state).plan or ""
 
     def test_basic_funnel(self):
         query = "what was the conversion from a page view to sign up?"
diff --git a/ee/hogai/eval/tests/test_eval_router.py b/ee/hogai/eval/tests/test_eval_router.py
index 25a84769dbfc8..c1307e9d40f00 100644
--- a/ee/hogai/eval/tests/test_eval_router.py
+++ b/ee/hogai/eval/tests/test_eval_router.py
@@ -1,8 +1,10 @@
+from typing import cast
+
 from langgraph.graph.state import CompiledStateGraph
 
 from ee.hogai.assistant import AssistantGraph
 from ee.hogai.eval.utils import EvalBaseTest
-from ee.hogai.utils import AssistantNodeName
+from ee.hogai.utils.types import AssistantNodeName, AssistantState
 from posthog.schema import HumanMessage, RouterMessage
 
 
@@ -15,8 +17,11 @@ def _call_node(self, query: str | list):
             .compile()
         )
         messages = [HumanMessage(content=query)] if isinstance(query, str) else query
-        state = graph.invoke({"messages": messages})
-        return state["messages"][-1].content
+        state = graph.invoke(
+            AssistantState(messages=messages),
+            self._get_config(),
+        )
+        return cast(RouterMessage, AssistantState.model_validate(state).messages[-1]).content
 
     def test_outputs_basic_trends_insight(self):
         query = "Show the $pageview trend"
diff --git a/ee/hogai/eval/tests/test_eval_trends_generator.py b/ee/hogai/eval/tests/test_eval_trends_generator.py
index c5341584ca2f7..496bbf0100b51 100644
--- a/ee/hogai/eval/tests/test_eval_trends_generator.py
+++ b/ee/hogai/eval/tests/test_eval_trends_generator.py
@@ -1,9 +1,11 @@
+from typing import cast
+
 from langgraph.graph.state import CompiledStateGraph
 
 from ee.hogai.assistant import AssistantGraph
 from ee.hogai.eval.utils import EvalBaseTest
-from ee.hogai.utils import AssistantNodeName
-from posthog.schema import AssistantTrendsQuery, HumanMessage
+from ee.hogai.utils.types import AssistantNodeName, AssistantState
+from posthog.schema import AssistantTrendsQuery, HumanMessage, VisualizationMessage
 
 
 class TestEvalTrendsGenerator(EvalBaseTest):
@@ -14,8 +16,11 @@ def _call_node(self, query: str, plan: str) -> AssistantTrendsQuery:
             .add_trends_generator(AssistantNodeName.END)
             .compile()
         )
-        state = graph.invoke({"messages": [HumanMessage(content=query)], "plan": plan})
-        return state["messages"][-1].answer
+        state = graph.invoke(
+            AssistantState(messages=[HumanMessage(content=query)], plan=plan),
+            self._get_config(),
+        )
+        return cast(VisualizationMessage, AssistantState.model_validate(state).messages[-1]).answer
 
     def test_node_replaces_equals_with_contains(self):
         query = "what is pageview trend for users with name John?"
diff --git a/ee/hogai/eval/tests/test_eval_trends_planner.py b/ee/hogai/eval/tests/test_eval_trends_planner.py
index e7ea741d03687..d4fbff456a91c 100644
--- a/ee/hogai/eval/tests/test_eval_trends_planner.py
+++ b/ee/hogai/eval/tests/test_eval_trends_planner.py
@@ -5,7 +5,7 @@
 
 from ee.hogai.assistant import AssistantGraph
 from ee.hogai.eval.utils import EvalBaseTest
-from ee.hogai.utils import AssistantNodeName
+from ee.hogai.utils.types import AssistantNodeName, AssistantState
 from posthog.schema import HumanMessage
 
 
@@ -40,8 +40,11 @@ def _call_node(self, query):
             .add_trends_planner(AssistantNodeName.END)
             .compile()
         )
-        state = graph.invoke({"messages": [HumanMessage(content=query)]})
-        return state["plan"]
+        state = graph.invoke(
+            AssistantState(messages=[HumanMessage(content=query)]),
+            self._get_config(),
+        )
+        return AssistantState.model_validate(state).plan or ""
 
     def test_no_excessive_property_filters(self):
         query = "Show the $pageview trend"
diff --git a/ee/hogai/eval/utils.py b/ee/hogai/eval/utils.py
index 1e50a75daefa2..6e03c4cfafa9f 100644
--- a/ee/hogai/eval/utils.py
+++ b/ee/hogai/eval/utils.py
@@ -3,15 +3,25 @@
 import pytest
 from django.test import override_settings
 from flaky import flaky
+from langchain_core.runnables import RunnableConfig
 
+from ee.models.assistant import Conversation
 from posthog.demo.matrix.manager import MatrixManager
 from posthog.tasks.demo_create_data import HedgeboxMatrix
-from posthog.test.base import BaseTest
+from posthog.test.base import NonAtomicBaseTest
 
 
 @pytest.mark.skipif(os.environ.get("DEEPEVAL") != "YES", reason="Only runs for the assistant evaluation")
 @flaky(max_runs=3, min_passes=1)
-class EvalBaseTest(BaseTest):
+class EvalBaseTest(NonAtomicBaseTest):
+    def _get_config(self) -> RunnableConfig:
+        conversation = Conversation.objects.create(team=self.team, user=self.user)
+        return {
+            "configurable": {
+                "thread_id": conversation.id,
+            }
+        }
+
     @classmethod
     def setUpTestData(cls):
         super().setUpTestData()
diff --git a/ee/hogai/funnels/nodes.py b/ee/hogai/funnels/nodes.py
index a55bc223847f2..6f71305e0b796 100644
--- a/ee/hogai/funnels/nodes.py
+++ b/ee/hogai/funnels/nodes.py
@@ -6,12 +6,12 @@
 from ee.hogai.schema_generator.nodes import SchemaGeneratorNode, SchemaGeneratorToolsNode
 from ee.hogai.schema_generator.utils import SchemaGeneratorOutput
 from ee.hogai.taxonomy_agent.nodes import TaxonomyAgentPlannerNode, TaxonomyAgentPlannerToolsNode
-from ee.hogai.utils import AssistantState
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.schema import AssistantFunnelsQuery
 
 
 class FunnelPlannerNode(TaxonomyAgentPlannerNode):
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         toolkit = FunnelsTaxonomyAgentToolkit(self._team)
         prompt = ChatPromptTemplate.from_messages(
             [
@@ -23,7 +23,7 @@ def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
 
 
 class FunnelPlannerToolsNode(TaxonomyAgentPlannerToolsNode):
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         toolkit = FunnelsTaxonomyAgentToolkit(self._team)
         return super()._run_with_toolkit(state, toolkit, config=config)
 
@@ -36,7 +36,7 @@ class FunnelGeneratorNode(SchemaGeneratorNode[AssistantFunnelsQuery]):
     OUTPUT_MODEL = FunnelsSchemaGeneratorOutput
     OUTPUT_SCHEMA = FUNNEL_SCHEMA
 
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         prompt = ChatPromptTemplate.from_messages(
             [
                 ("system", FUNNEL_SYSTEM_PROMPT),
diff --git a/ee/hogai/funnels/prompts.py b/ee/hogai/funnels/prompts.py
index b2deec894a070..3808809c173a7 100644
--- a/ee/hogai/funnels/prompts.py
+++ b/ee/hogai/funnels/prompts.py
@@ -12,6 +12,8 @@
 {{react_format}}
 </agent_info>
 
+{{react_human_in_the_loop}}
+
 Below you will find information on how to correctly discover the taxonomy of the user's data.
 
 <general_knowledge>
diff --git a/ee/hogai/funnels/test/test_nodes.py b/ee/hogai/funnels/test/test_nodes.py
index 5c65b14110599..4f4e9fca0e5d4 100644
--- a/ee/hogai/funnels/test/test_nodes.py
+++ b/ee/hogai/funnels/test/test_nodes.py
@@ -4,6 +4,7 @@
 from langchain_core.runnables import RunnableLambda
 
 from ee.hogai.funnels.nodes import FunnelGeneratorNode, FunnelsSchemaGeneratorOutput
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.schema import (
     AssistantFunnelsQuery,
     HumanMessage,
@@ -15,6 +16,7 @@
 @override_settings(IN_UNIT_TESTING=True)
 class TestFunnelsGeneratorNode(ClickhouseTestMixin, APIBaseTest):
     def setUp(self):
+        super().setUp()
         self.schema = AssistantFunnelsQuery(series=[])
 
     def test_node_runs(self):
@@ -24,16 +26,13 @@ def test_node_runs(self):
                 lambda _: FunnelsSchemaGeneratorOutput(query=self.schema).model_dump()
             )
             new_state = node.run(
-                {
-                    "messages": [HumanMessage(content="Text")],
-                    "plan": "Plan",
-                },
+                AssistantState(messages=[HumanMessage(content="Text")], plan="Plan"),
                 {},
             )
             self.assertEqual(
                 new_state,
-                {
-                    "messages": [VisualizationMessage(answer=self.schema, plan="Plan", done=True)],
-                    "intermediate_steps": None,
-                },
+                PartialAssistantState(
+                    messages=[VisualizationMessage(answer=self.schema, plan="Plan", id=new_state.messages[0].id)],
+                    intermediate_steps=None,
+                ),
             )
diff --git a/ee/hogai/funnels/toolkit.py b/ee/hogai/funnels/toolkit.py
index 8d6407027aac1..ae603519cc331 100644
--- a/ee/hogai/funnels/toolkit.py
+++ b/ee/hogai/funnels/toolkit.py
@@ -1,5 +1,5 @@
 from ee.hogai.taxonomy_agent.toolkit import TaxonomyAgentToolkit, ToolkitTool
-from ee.hogai.utils import dereference_schema
+from ee.hogai.utils.helpers import dereference_schema
 from posthog.schema import AssistantFunnelsQuery
 
 
diff --git a/ee/hogai/graph.py b/ee/hogai/graph.py
index 79e5f914097ce..bf961d6bb9aa8 100644
--- a/ee/hogai/graph.py
+++ b/ee/hogai/graph.py
@@ -1,10 +1,10 @@
 from collections.abc import Hashable
 from typing import Optional, cast
 
-from langfuse.callback import CallbackHandler
+from langchain_core.runnables.base import RunnableLike
 from langgraph.graph.state import StateGraph
 
-from ee import settings
+from ee.hogai.django_checkpoint.checkpointer import DjangoCheckpointer
 from ee.hogai.funnels.nodes import (
     FunnelGeneratorNode,
     FunnelGeneratorToolsNode,
@@ -19,15 +19,10 @@
     TrendsPlannerNode,
     TrendsPlannerToolsNode,
 )
-from ee.hogai.utils import AssistantNodeName, AssistantState
+from ee.hogai.utils.types import AssistantNodeName, AssistantState
 from posthog.models.team.team import Team
 
-if settings.LANGFUSE_PUBLIC_KEY:
-    langfuse_handler = CallbackHandler(
-        public_key=settings.LANGFUSE_PUBLIC_KEY, secret_key=settings.LANGFUSE_SECRET_KEY, host=settings.LANGFUSE_HOST
-    )
-else:
-    langfuse_handler = None
+checkpointer = DjangoCheckpointer()
 
 
 class AssistantGraph:
@@ -45,10 +40,14 @@ def add_edge(self, from_node: AssistantNodeName, to_node: AssistantNodeName):
         self._graph.add_edge(from_node, to_node)
         return self
 
+    def add_node(self, node: AssistantNodeName, action: RunnableLike):
+        self._graph.add_node(node, action)
+        return self
+
     def compile(self):
         if not self._has_start_node:
             raise ValueError("Start node not added to the graph")
-        return self._graph.compile()
+        return self._graph.compile(checkpointer=checkpointer)
 
     def add_start(self):
         return self.add_edge(AssistantNodeName.START, AssistantNodeName.ROUTER)
diff --git a/ee/hogai/router/nodes.py b/ee/hogai/router/nodes.py
index c9151faaabc29..f6aeacdebbe6b 100644
--- a/ee/hogai/router/nodes.py
+++ b/ee/hogai/router/nodes.py
@@ -1,4 +1,5 @@
 from typing import Literal, cast
+from uuid import uuid4
 
 from langchain_core.messages import AIMessage as LangchainAIMessage, BaseMessage
 from langchain_core.prompts import ChatPromptTemplate
@@ -11,7 +12,8 @@
     ROUTER_SYSTEM_PROMPT,
     ROUTER_USER_PROMPT,
 )
-from ee.hogai.utils import AssistantState, AssistantNode
+from ee.hogai.utils.nodes import AssistantNode
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.schema import HumanMessage, RouterMessage
 
 RouteName = Literal["trends", "funnel"]
@@ -22,7 +24,7 @@ class RouterOutput(BaseModel):
 
 
 class RouterNode(AssistantNode):
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         prompt = ChatPromptTemplate.from_messages(
             [
                 ("system", ROUTER_SYSTEM_PROMPT),
@@ -31,10 +33,10 @@ def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
         ) + self._construct_messages(state)
         chain = prompt | self._model
         output: RouterOutput = chain.invoke({}, config)
-        return {"messages": [RouterMessage(content=output.visualization_type)]}
+        return PartialAssistantState(messages=[RouterMessage(content=output.visualization_type, id=str(uuid4()))])
 
     def router(self, state: AssistantState) -> RouteName:
-        last_message = state["messages"][-1]
+        last_message = state.messages[-1]
         if isinstance(last_message, RouterMessage):
             return cast(RouteName, last_message.content)
         raise ValueError("Invalid route.")
@@ -47,7 +49,7 @@ def _model(self):
 
     def _construct_messages(self, state: AssistantState):
         history: list[BaseMessage] = []
-        for message in state["messages"]:
+        for message in state.messages:
             if isinstance(message, HumanMessage):
                 history += ChatPromptTemplate.from_messages(
                     [("user", ROUTER_USER_PROMPT.strip())], template_format="mustache"
diff --git a/ee/hogai/router/test/test_nodes.py b/ee/hogai/router/test/test_nodes.py
index 06014fb0b9f59..53074a381b804 100644
--- a/ee/hogai/router/test/test_nodes.py
+++ b/ee/hogai/router/test/test_nodes.py
@@ -2,11 +2,11 @@
 from unittest.mock import patch
 
 from django.test import override_settings
-from langchain_core.messages import AIMessage as LangchainAIMessage
-from langchain_core.messages import HumanMessage as LangchainHumanMessage
+from langchain_core.messages import AIMessage as LangchainAIMessage, HumanMessage as LangchainHumanMessage
 from langchain_core.runnables import RunnableLambda
 
 from ee.hogai.router.nodes import RouterNode, RouterOutput
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.schema import (
     HumanMessage,
     RouterMessage,
@@ -19,7 +19,7 @@
 class TestRouterNode(ClickhouseTestMixin, APIBaseTest):
     def test_router(self):
         node = RouterNode(self.team)
-        state: Any = {"messages": [RouterMessage(content="trends")]}
+        state: Any = AssistantState(messages=[RouterMessage(content="trends")])
         self.assertEqual(node.router(state), "trends")
 
     def test_node_runs(self):
@@ -28,28 +28,36 @@ def test_node_runs(self):
             return_value=RunnableLambda(lambda _: RouterOutput(visualization_type="funnel")),
         ):
             node = RouterNode(self.team)
-            state: Any = {"messages": [HumanMessage(content="generate trends")]}
-            self.assertEqual(node.run(state, {}), {"messages": [RouterMessage(content="funnel")]})
+            state: Any = AssistantState(messages=[HumanMessage(content="generate trends")])
+            next_state = node.run(state, {})
+            self.assertEqual(
+                next_state,
+                PartialAssistantState(messages=[RouterMessage(content="funnel", id=next_state.messages[0].id)]),
+            )
 
         with patch(
             "ee.hogai.router.nodes.RouterNode._model",
             return_value=RunnableLambda(lambda _: RouterOutput(visualization_type="trends")),
         ):
             node = RouterNode(self.team)
-            state: Any = {"messages": [HumanMessage(content="generate trends")]}
-            self.assertEqual(node.run(state, {}), {"messages": [RouterMessage(content="trends")]})
+            state: Any = AssistantState(messages=[HumanMessage(content="generate trends")])
+            next_state = node.run(state, {})
+            self.assertEqual(
+                next_state,
+                PartialAssistantState(messages=[RouterMessage(content="trends", id=next_state.messages[0].id)]),
+            )
 
     def test_node_reconstructs_conversation(self):
         node = RouterNode(self.team)
-        state: Any = {"messages": [HumanMessage(content="generate trends")]}
+        state: Any = AssistantState(messages=[HumanMessage(content="generate trends")])
         self.assertEqual(node._construct_messages(state), [LangchainHumanMessage(content="Question: generate trends")])
-        state = {
-            "messages": [
+        state = AssistantState(
+            messages=[
                 HumanMessage(content="generate trends"),
                 RouterMessage(content="trends"),
                 VisualizationMessage(),
             ]
-        }
+        )
         self.assertEqual(
             node._construct_messages(state),
             [LangchainHumanMessage(content="Question: generate trends"), LangchainAIMessage(content="trends")],
diff --git a/ee/hogai/schema_generator/nodes.py b/ee/hogai/schema_generator/nodes.py
index c5e7ffbba85c4..4bed02fd462cc 100644
--- a/ee/hogai/schema_generator/nodes.py
+++ b/ee/hogai/schema_generator/nodes.py
@@ -1,10 +1,16 @@
-import itertools
 import xml.etree.ElementTree as ET
+from collections.abc import Sequence
 from functools import cached_property
 from typing import Generic, Optional, TypeVar
+from uuid import uuid4
 
 from langchain_core.agents import AgentAction
-from langchain_core.messages import AIMessage as LangchainAssistantMessage, BaseMessage, merge_message_runs
+from langchain_core.messages import (
+    AIMessage as LangchainAssistantMessage,
+    BaseMessage,
+    HumanMessage as LangchainHumanMessage,
+    merge_message_runs,
+)
 from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
 from langchain_core.runnables import RunnableConfig
 from langchain_openai import ChatOpenAI
@@ -23,10 +29,14 @@
     QUESTION_PROMPT,
 )
 from ee.hogai.schema_generator.utils import SchemaGeneratorOutput
-from ee.hogai.utils import AssistantNode, AssistantState, filter_visualization_conversation
+from ee.hogai.utils.helpers import find_last_message_of_type, slice_messages_to_conversation_start
+from ee.hogai.utils.nodes import AssistantNode
+from ee.hogai.utils.types import AssistantMessageUnion, AssistantState, PartialAssistantState
 from posthog.models.group_type_mapping import GroupTypeMapping
 from posthog.schema import (
+    AssistantMessage,
     FailureMessage,
+    HumanMessage,
     VisualizationMessage,
 )
 
@@ -63,9 +73,10 @@ def _run_with_prompt(
         state: AssistantState,
         prompt: ChatPromptTemplate,
         config: Optional[RunnableConfig] = None,
-    ) -> AssistantState:
-        generated_plan = state.get("plan", "")
-        intermediate_steps = state.get("intermediate_steps") or []
+    ) -> PartialAssistantState:
+        start_id = state.start_id
+        generated_plan = state.plan or ""
+        intermediate_steps = state.intermediate_steps or []
         validation_error_message = intermediate_steps[-1][1] if intermediate_steps else None
 
         generation_prompt = prompt + self._construct_messages(state, validation_error_message=validation_error_message)
@@ -79,41 +90,42 @@ def _run_with_prompt(
         except PydanticOutputParserException as e:
             # Generation step is expensive. After a second unsuccessful attempt, it's better to send a failure message.
             if len(intermediate_steps) >= 2:
-                return {
-                    "messages": [
+                return PartialAssistantState(
+                    messages=[
                         FailureMessage(
                             content=f"Oops! It looks like I’m having trouble generating this {self.INSIGHT_NAME} insight. Could you please try again?"
                         )
                     ],
-                    "intermediate_steps": None,
-                }
+                    intermediate_steps=None,
+                )
 
-            return {
-                "intermediate_steps": [
+            return PartialAssistantState(
+                intermediate_steps=[
                     *intermediate_steps,
                     (AgentAction("handle_incorrect_response", e.llm_output, e.validation_message), None),
                 ],
-            }
+            )
 
-        return {
-            "messages": [
+        return PartialAssistantState(
+            messages=[
                 VisualizationMessage(
                     plan=generated_plan,
                     answer=message.query,
-                    done=True,
+                    initiator=start_id,
+                    id=str(uuid4()),
                 )
             ],
-            "intermediate_steps": None,
-        }
+            intermediate_steps=None,
+        )
 
     def router(self, state: AssistantState):
-        if state.get("intermediate_steps") is not None:
+        if state.intermediate_steps:
             return "tools"
         return "next"
 
     @cached_property
     def _group_mapping_prompt(self) -> str:
-        groups = GroupTypeMapping.objects.filter(team=self._team).order_by("group_type_index")
+        groups = GroupTypeMapping.objects.filter(project_id=self._team.project_id).order_by("group_type_index")
         if not groups:
             return "The user has not defined any groups."
 
@@ -123,15 +135,25 @@ def _group_mapping_prompt(self) -> str:
         )
         return ET.tostring(root, encoding="unicode")
 
+    def _get_human_viz_message_mapping(self, messages: Sequence[AssistantMessageUnion]) -> dict[str, int]:
+        mapping: dict[str, int] = {}
+        for idx, msg in enumerate(messages):
+            if isinstance(msg, VisualizationMessage) and msg.initiator is not None:
+                mapping[msg.initiator] = idx
+        return mapping
+
     def _construct_messages(
         self, state: AssistantState, validation_error_message: Optional[str] = None
     ) -> list[BaseMessage]:
         """
         Reconstruct the conversation for the generation. Take all previously generated questions, plans, and schemas, and return the history.
         """
-        messages = state.get("messages", [])
-        generated_plan = state.get("plan", "")
+        messages = state.messages
+        generated_plan = state.plan
+        start_id = state.start_id
 
+        if start_id is not None:
+            messages = slice_messages_to_conversation_start(messages, start_id)
         if len(messages) == 0:
             return []
 
@@ -141,43 +163,61 @@ def _construct_messages(
             )
         ]
 
-        human_messages, visualization_messages = filter_visualization_conversation(messages)
-        first_ai_message = True
+        msg_mapping = self._get_human_viz_message_mapping(messages)
+        initiator_message = messages[-1]
+        last_viz_message = find_last_message_of_type(messages, VisualizationMessage)
+
+        for message in messages:
+            # The initial human message and the new plan are added to the end of the conversation.
+            if message == initiator_message:
+                continue
+            if isinstance(message, HumanMessage):
+                if message.id and (viz_message_idx := msg_mapping.get(message.id)):
+                    # Plans go first.
+                    viz_message = messages[viz_message_idx]
+                    if isinstance(viz_message, VisualizationMessage):
+                        conversation.append(
+                            HumanMessagePromptTemplate.from_template(PLAN_PROMPT, template_format="mustache").format(
+                                plan=viz_message.plan or ""
+                            )
+                        )
 
-        for idx, (human_message, ai_message) in enumerate(
-            itertools.zip_longest(human_messages, visualization_messages)
-        ):
-            # Plans go first
-            if ai_message:
-                conversation.append(
-                    HumanMessagePromptTemplate.from_template(
-                        PLAN_PROMPT if first_ai_message else NEW_PLAN_PROMPT,
-                        template_format="mustache",
-                    ).format(plan=ai_message.plan or "")
-                )
-                first_ai_message = False
-            elif generated_plan:
-                conversation.append(
-                    HumanMessagePromptTemplate.from_template(
-                        PLAN_PROMPT if first_ai_message else NEW_PLAN_PROMPT,
-                        template_format="mustache",
-                    ).format(plan=generated_plan)
+                    # Augment with the prompt previous initiator messages.
+                    conversation.append(
+                        HumanMessagePromptTemplate.from_template(QUESTION_PROMPT, template_format="mustache").format(
+                            question=message.content
+                        )
+                    )
+                # Otherwise, just append the human message.
+                else:
+                    conversation.append(LangchainHumanMessage(content=message.content))
+            # Summary, human-in-the-loop messages.
+            elif isinstance(message, AssistantMessage):
+                conversation.append(LangchainAssistantMessage(content=message.content))
+
+        # Include only last generated schema because it doesn't need more context.
+        if last_viz_message:
+            conversation.append(
+                LangchainAssistantMessage(
+                    content=last_viz_message.answer.model_dump_json() if last_viz_message.answer else ""
                 )
-
-            # Then questions
-            if human_message:
+            )
+        # Add the initiator message and the generated plan to the end, so instructions are clear.
+        if isinstance(initiator_message, HumanMessage):
+            if generated_plan:
+                plan_prompt = PLAN_PROMPT if messages[0] == initiator_message else NEW_PLAN_PROMPT
                 conversation.append(
-                    HumanMessagePromptTemplate.from_template(QUESTION_PROMPT, template_format="mustache").format(
-                        question=human_message.content
+                    HumanMessagePromptTemplate.from_template(plan_prompt, template_format="mustache").format(
+                        plan=generated_plan or ""
                     )
                 )
-
-            # Then schemas, but include only last generated schema because it doesn't need more context.
-            if ai_message and idx + 1 == len(visualization_messages):
-                conversation.append(
-                    LangchainAssistantMessage(content=ai_message.answer.model_dump_json() if ai_message.answer else "")
+            conversation.append(
+                HumanMessagePromptTemplate.from_template(QUESTION_PROMPT, template_format="mustache").format(
+                    question=initiator_message.content
                 )
+            )
 
+        # Retries must be added to the end of the conversation.
         if validation_error_message:
             conversation.append(
                 HumanMessagePromptTemplate.from_template(FAILOVER_PROMPT, template_format="mustache").format(
@@ -193,10 +233,10 @@ class SchemaGeneratorToolsNode(AssistantNode):
     Used for failover from generation errors.
     """
 
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
-        intermediate_steps = state.get("intermediate_steps", [])
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
+        intermediate_steps = state.intermediate_steps or []
         if not intermediate_steps:
-            return state
+            return PartialAssistantState()
 
         action, _ = intermediate_steps[-1]
         prompt = (
@@ -205,9 +245,9 @@ def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
             .content
         )
 
-        return {
-            "intermediate_steps": [
+        return PartialAssistantState(
+            intermediate_steps=[
                 *intermediate_steps[:-1],
                 (action, str(prompt)),
             ]
-        }
+        )
diff --git a/ee/hogai/schema_generator/test/test_nodes.py b/ee/hogai/schema_generator/test/test_nodes.py
index 795045af50b56..b44154b93b927 100644
--- a/ee/hogai/schema_generator/test/test_nodes.py
+++ b/ee/hogai/schema_generator/test/test_nodes.py
@@ -4,10 +4,11 @@
 from django.test import override_settings
 from langchain_core.agents import AgentAction
 from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import RunnableLambda
+from langchain_core.runnables import RunnableConfig, RunnableLambda
 
 from ee.hogai.schema_generator.nodes import SchemaGeneratorNode, SchemaGeneratorToolsNode
 from ee.hogai.schema_generator.utils import SchemaGeneratorOutput
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.schema import (
     AssistantMessage,
     AssistantTrendsQuery,
@@ -16,7 +17,7 @@
     RouterMessage,
     VisualizationMessage,
 )
-from posthog.test.base import APIBaseTest, ClickhouseTestMixin
+from posthog.test.base import BaseTest
 
 TestSchema = SchemaGeneratorOutput[AssistantTrendsQuery]
 
@@ -26,7 +27,7 @@ class DummyGeneratorNode(SchemaGeneratorNode[AssistantTrendsQuery]):
     OUTPUT_MODEL = SchemaGeneratorOutput[AssistantTrendsQuery]
     OUTPUT_SCHEMA = {}
 
-    def run(self, state, config):
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         prompt = ChatPromptTemplate.from_messages(
             [
                 ("system", "system_prompt"),
@@ -36,8 +37,9 @@ def run(self, state, config):
 
 
 @override_settings(IN_UNIT_TESTING=True)
-class TestSchemaGeneratorNode(ClickhouseTestMixin, APIBaseTest):
+class TestSchemaGeneratorNode(BaseTest):
     def setUp(self):
+        super().setUp()
         self.schema = AssistantTrendsQuery(series=[])
 
     def test_node_runs(self):
@@ -45,23 +47,23 @@ def test_node_runs(self):
         with patch.object(DummyGeneratorNode, "_model") as generator_model_mock:
             generator_model_mock.return_value = RunnableLambda(lambda _: TestSchema(query=self.schema).model_dump())
             new_state = node.run(
-                {
-                    "messages": [HumanMessage(content="Text")],
-                    "plan": "Plan",
-                },
+                AssistantState(
+                    messages=[HumanMessage(content="Text", id="0")],
+                    plan="Plan",
+                    start_id="0",
+                ),
                 {},
             )
-            self.assertEqual(
-                new_state,
-                {
-                    "messages": [VisualizationMessage(answer=self.schema, plan="Plan", done=True)],
-                    "intermediate_steps": None,
-                },
-            )
+            self.assertIsNone(new_state.intermediate_steps)
+            self.assertEqual(len(new_state.messages), 1)
+            self.assertEqual(new_state.messages[0].type, "ai/viz")
+            self.assertEqual(new_state.messages[0].answer, self.schema)
 
-    def test_agent_reconstructs_conversation(self):
+    def test_agent_reconstructs_conversation_and_does_not_add_an_empty_plan(self):
         node = DummyGeneratorNode(self.team)
-        history = node._construct_messages({"messages": [HumanMessage(content="Text")]})
+        history = node._construct_messages(
+            AssistantState(messages=[HumanMessage(content="Text", id="0")], start_id="0")
+        )
         self.assertEqual(len(history), 2)
         self.assertEqual(history[0].type, "human")
         self.assertIn("mapping", history[0].content)
@@ -69,7 +71,11 @@ def test_agent_reconstructs_conversation(self):
         self.assertIn("Answer to this question:", history[1].content)
         self.assertNotIn("{{question}}", history[1].content)
 
-        history = node._construct_messages({"messages": [HumanMessage(content="Text")], "plan": "randomplan"})
+    def test_agent_reconstructs_conversation_adds_plan(self):
+        node = DummyGeneratorNode(self.team)
+        history = node._construct_messages(
+            AssistantState(messages=[HumanMessage(content="Text", id="0")], plan="randomplan", start_id="0")
+        )
         self.assertEqual(len(history), 3)
         self.assertEqual(history[0].type, "human")
         self.assertIn("mapping", history[0].content)
@@ -82,16 +88,18 @@ def test_agent_reconstructs_conversation(self):
         self.assertNotIn("{{question}}", history[2].content)
         self.assertIn("Text", history[2].content)
 
+    def test_agent_reconstructs_conversation_can_handle_follow_ups(self):
         node = DummyGeneratorNode(self.team)
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="Text"),
-                    VisualizationMessage(answer=self.schema, plan="randomplan"),
-                    HumanMessage(content="Follow Up"),
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Text", id="0"),
+                    VisualizationMessage(answer=self.schema, plan="randomplan", id="1", initiator="0"),
+                    HumanMessage(content="Follow Up", id="2"),
                 ],
-                "plan": "newrandomplan",
-            }
+                plan="newrandomplan",
+                start_id="2",
+            )
         )
 
         self.assertEqual(len(history), 6)
@@ -116,13 +124,41 @@ def test_agent_reconstructs_conversation(self):
         self.assertNotIn("{{question}}", history[5].content)
         self.assertIn("Follow Up", history[5].content)
 
-    def test_agent_reconstructs_conversation_and_merges_messages(self):
+    def test_agent_reconstructs_conversation_and_does_not_merge_messages(self):
+        node = DummyGeneratorNode(self.team)
+        history = node._construct_messages(
+            AssistantState(
+                messages=[HumanMessage(content="Te", id="0"), HumanMessage(content="xt", id="1")],
+                plan="randomplan",
+                start_id="1",
+            )
+        )
+        self.assertEqual(len(history), 4)
+        self.assertEqual(history[0].type, "human")
+        self.assertIn("mapping", history[0].content)
+        self.assertIn("Te", history[1].content)
+        self.assertEqual(history[2].type, "human")
+        self.assertNotIn("{{plan}}", history[2].content)
+        self.assertIn("randomplan", history[2].content)
+        self.assertEqual(history[3].type, "human")
+        self.assertIn("Answer to this question:", history[3].content)
+        self.assertNotIn("{{question}}", history[3].content)
+        self.assertEqual(history[3].type, "human")
+        self.assertIn("xt", history[3].content)
+
+    def test_filters_out_human_in_the_loop_after_initiator(self):
         node = DummyGeneratorNode(self.team)
         history = node._construct_messages(
-            {
-                "messages": [HumanMessage(content="Te"), HumanMessage(content="xt")],
-                "plan": "randomplan",
-            }
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Text", id="0"),
+                    VisualizationMessage(answer=self.schema, plan="randomplan", initiator="0", id="1"),
+                    HumanMessage(content="Follow", id="2"),
+                    HumanMessage(content="Up", id="3"),
+                ],
+                plan="newrandomplan",
+                start_id="0",
+            )
         )
         self.assertEqual(len(history), 3)
         self.assertEqual(history[0].type, "human")
@@ -134,104 +170,114 @@ def test_agent_reconstructs_conversation_and_merges_messages(self):
         self.assertEqual(history[2].type, "human")
         self.assertIn("Answer to this question:", history[2].content)
         self.assertNotIn("{{question}}", history[2].content)
-        self.assertIn("Te\nxt", history[2].content)
+        self.assertIn("Text", history[2].content)
 
+    def test_preserves_human_in_the_loop_before_initiator(self):
         node = DummyGeneratorNode(self.team)
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="Text"),
-                    VisualizationMessage(answer=self.schema, plan="randomplan"),
-                    HumanMessage(content="Follow"),
-                    HumanMessage(content="Up"),
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Question 1", id="0"),
+                    AssistantMessage(content="Loop", id="1"),
+                    HumanMessage(content="Answer", id="2"),
+                    VisualizationMessage(answer=self.schema, plan="randomplan", initiator="0", id="3"),
+                    HumanMessage(content="Question 2", id="4"),
                 ],
-                "plan": "newrandomplan",
-            }
+                plan="newrandomplan",
+                start_id="4",
+            )
         )
-
-        self.assertEqual(len(history), 6)
+        self.assertEqual(len(history), 8)
         self.assertEqual(history[0].type, "human")
         self.assertIn("mapping", history[0].content)
         self.assertEqual(history[1].type, "human")
         self.assertIn("the plan", history[1].content)
         self.assertNotIn("{{plan}}", history[1].content)
         self.assertIn("randomplan", history[1].content)
-        self.assertEqual(history[2].type, "human")
-        self.assertIn("Answer to this question:", history[2].content)
         self.assertNotIn("{{question}}", history[2].content)
-        self.assertIn("Text", history[2].content)
+        self.assertIn("Question 1", history[2].content)
         self.assertEqual(history[3].type, "ai")
-        self.assertEqual(history[3].content, self.schema.model_dump_json())
+        self.assertEqual("Loop", history[3].content)
         self.assertEqual(history[4].type, "human")
-        self.assertIn("the new plan", history[4].content)
-        self.assertNotIn("{{plan}}", history[4].content)
-        self.assertIn("newrandomplan", history[4].content)
-        self.assertEqual(history[5].type, "human")
-        self.assertIn("Answer to this question:", history[5].content)
-        self.assertNotIn("{{question}}", history[5].content)
-        self.assertIn("Follow\nUp", history[5].content)
+        self.assertEqual("Answer", history[4].content)
+        self.assertEqual(history[5].type, "ai")
+        self.assertEqual(history[6].type, "human")
+        self.assertIn("the new plan", history[6].content)
+        self.assertIn("newrandomplan", history[6].content)
+        self.assertEqual(history[7].type, "human")
+        self.assertNotIn("{{question}}", history[7].content)
+        self.assertIn("Question 2", history[7].content)
 
     def test_agent_reconstructs_typical_conversation(self):
         node = DummyGeneratorNode(self.team)
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="Question 1"),
-                    RouterMessage(content="trends"),
-                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 1"),
-                    AssistantMessage(content="Summary 1"),
-                    HumanMessage(content="Question 2"),
-                    RouterMessage(content="funnel"),
-                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 2"),
-                    AssistantMessage(content="Summary 2"),
-                    HumanMessage(content="Question 3"),
-                    RouterMessage(content="funnel"),
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Question 1", id="0"),
+                    RouterMessage(content="trends", id="1"),
+                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 1", initiator="0", id="2"),
+                    AssistantMessage(content="Summary 1", id="3"),
+                    HumanMessage(content="Question 2", id="4"),
+                    RouterMessage(content="funnel", id="5"),
+                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 2", initiator="4", id="6"),
+                    AssistantMessage(content="Summary 2", id="7"),
+                    HumanMessage(content="Question 3", id="8"),
+                    RouterMessage(content="funnel", id="9"),
                 ],
-                "plan": "Plan 3",
-            }
+                plan="Plan 3",
+                start_id="8",
+            )
         )
-        self.assertEqual(len(history), 8)
+
+        self.assertEqual(len(history), 10)
         self.assertEqual(history[0].type, "human")
         self.assertIn("mapping", history[0].content)
         self.assertEqual(history[1].type, "human")
         self.assertIn("Plan 1", history[1].content)
         self.assertEqual(history[2].type, "human")
         self.assertIn("Question 1", history[2].content)
-        self.assertEqual(history[3].type, "human")
-        self.assertIn("Plan 2", history[3].content)
+        self.assertEqual(history[3].type, "ai")
+        self.assertEqual(history[3].content, "Summary 1")
         self.assertEqual(history[4].type, "human")
-        self.assertIn("Question 2", history[4].content)
-        self.assertEqual(history[5].type, "ai")
-        self.assertEqual(history[6].type, "human")
-        self.assertIn("Plan 3", history[6].content)
-        self.assertEqual(history[7].type, "human")
-        self.assertIn("Question 3", history[7].content)
-
-    def test_prompt(self):
+        self.assertIn("Plan 2", history[4].content)
+        self.assertEqual(history[5].type, "human")
+        self.assertIn("Question 2", history[5].content)
+        self.assertEqual(history[6].type, "ai")
+        self.assertEqual(history[6].content, "Summary 2")
+        self.assertEqual(history[7].type, "ai")
+        self.assertEqual(history[8].type, "human")
+        self.assertIn("Plan 3", history[8].content)
+        self.assertEqual(history[9].type, "human")
+        self.assertIn("Question 3", history[9].content)
+
+    def test_prompt_messages_merged(self):
         node = DummyGeneratorNode(self.team)
-        state = {
-            "messages": [
-                HumanMessage(content="Question 1"),
-                RouterMessage(content="trends"),
-                VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 1"),
-                AssistantMessage(content="Summary 1"),
-                HumanMessage(content="Question 2"),
-                RouterMessage(content="funnel"),
-                VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 2"),
-                AssistantMessage(content="Summary 2"),
-                HumanMessage(content="Question 3"),
-                RouterMessage(content="funnel"),
+        state = AssistantState(
+            messages=[
+                HumanMessage(content="Question 1", id="0"),
+                RouterMessage(content="trends", id="1"),
+                VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 1", initiator="0", id="2"),
+                AssistantMessage(content="Summary 1", id="3"),
+                HumanMessage(content="Question 2", id="4"),
+                RouterMessage(content="funnel", id="5"),
+                VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 2", initiator="4", id="6"),
+                AssistantMessage(content="Summary 2", id="7"),
+                HumanMessage(content="Question 3", id="8"),
+                RouterMessage(content="funnel", id="9"),
             ],
-            "plan": "Plan 3",
-        }
+            plan="Plan 3",
+            start_id="8",
+        )
         with patch.object(DummyGeneratorNode, "_model") as generator_model_mock:
 
             def assert_prompt(prompt):
-                self.assertEqual(len(prompt), 4)
+                self.assertEqual(len(prompt), 6)
                 self.assertEqual(prompt[0].type, "system")
                 self.assertEqual(prompt[1].type, "human")
                 self.assertEqual(prompt[2].type, "ai")
                 self.assertEqual(prompt[3].type, "human")
+                self.assertEqual(prompt[4].type, "ai")
+                self.assertEqual(prompt[5].type, "human")
 
             generator_model_mock.return_value = RunnableLambda(assert_prompt)
             node.run(state, {})
@@ -244,19 +290,17 @@ def test_failover_with_incorrect_schema(self):
             schema["query"] = []
             generator_model_mock.return_value = RunnableLambda(lambda _: json.dumps(schema))
 
-            new_state = node.run({"messages": [HumanMessage(content="Text")]}, {})
-            self.assertIn("intermediate_steps", new_state)
-            self.assertEqual(len(new_state["intermediate_steps"]), 1)
+            new_state = node.run(AssistantState(messages=[HumanMessage(content="Text")]), {})
+            self.assertEqual(len(new_state.intermediate_steps), 1)
 
             new_state = node.run(
-                {
-                    "messages": [HumanMessage(content="Text")],
-                    "intermediate_steps": [(AgentAction(tool="", tool_input="", log="exception"), "exception")],
-                },
+                AssistantState(
+                    messages=[HumanMessage(content="Text")],
+                    intermediate_steps=[(AgentAction(tool="", tool_input="", log="exception"), "exception")],
+                ),
                 {},
             )
-            self.assertIn("intermediate_steps", new_state)
-            self.assertEqual(len(new_state["intermediate_steps"]), 2)
+            self.assertEqual(len(new_state.intermediate_steps), 2)
 
     def test_node_leaves_failover(self):
         node = DummyGeneratorNode(self.team)
@@ -266,25 +310,25 @@ def test_node_leaves_failover(self):
             return_value=RunnableLambda(lambda _: TestSchema(query=self.schema).model_dump()),
         ):
             new_state = node.run(
-                {
-                    "messages": [HumanMessage(content="Text")],
-                    "intermediate_steps": [(AgentAction(tool="", tool_input="", log="exception"), "exception")],
-                },
+                AssistantState(
+                    messages=[HumanMessage(content="Text")],
+                    intermediate_steps=[(AgentAction(tool="", tool_input="", log="exception"), "exception")],
+                ),
                 {},
             )
-            self.assertIsNone(new_state["intermediate_steps"])
+            self.assertIsNone(new_state.intermediate_steps)
 
             new_state = node.run(
-                {
-                    "messages": [HumanMessage(content="Text")],
-                    "intermediate_steps": [
+                AssistantState(
+                    messages=[HumanMessage(content="Text")],
+                    intermediate_steps=[
                         (AgentAction(tool="", tool_input="", log="exception"), "exception"),
                         (AgentAction(tool="", tool_input="", log="exception"), "exception"),
                     ],
-                },
+                ),
                 {},
             )
-            self.assertIsNone(new_state["intermediate_steps"])
+            self.assertIsNone(new_state.intermediate_steps)
 
     def test_node_leaves_failover_after_second_unsuccessful_attempt(self):
         node = DummyGeneratorNode(self.team)
@@ -295,29 +339,30 @@ def test_node_leaves_failover_after_second_unsuccessful_attempt(self):
             generator_model_mock.return_value = RunnableLambda(lambda _: json.dumps(schema))
 
             new_state = node.run(
-                {
-                    "messages": [HumanMessage(content="Text")],
-                    "intermediate_steps": [
+                AssistantState(
+                    messages=[HumanMessage(content="Text")],
+                    intermediate_steps=[
                         (AgentAction(tool="", tool_input="", log="exception"), "exception"),
                         (AgentAction(tool="", tool_input="", log="exception"), "exception"),
                     ],
-                },
+                ),
                 {},
             )
-            self.assertIsNone(new_state["intermediate_steps"])
-            self.assertEqual(len(new_state["messages"]), 1)
-            self.assertIsInstance(new_state["messages"][0], FailureMessage)
+            self.assertIsNone(new_state.intermediate_steps)
+            self.assertEqual(len(new_state.messages), 1)
+            self.assertIsInstance(new_state.messages[0], FailureMessage)
 
     def test_agent_reconstructs_conversation_with_failover(self):
         action = AgentAction(tool="fix", tool_input="validation error", log="exception")
         node = DummyGeneratorNode(self.team)
         history = node._construct_messages(
-            {
-                "messages": [HumanMessage(content="Text")],
-                "plan": "randomplan",
-                "intermediate_steps": [(action, "uniqexception")],
-            },
-            "uniqexception",
+            AssistantState(
+                messages=[HumanMessage(content="Text", id="0")],
+                plan="randomplan",
+                intermediate_steps=[(action, "uniqexception")],
+                start_id="0",
+            ),
+            validation_error_message="uniqexception",
         )
         self.assertEqual(len(history), 4)
         self.assertEqual(history[0].type, "human")
@@ -337,14 +382,14 @@ def test_agent_reconstructs_conversation_with_failover(self):
     def test_agent_reconstructs_conversation_with_failed_messages(self):
         node = DummyGeneratorNode(self.team)
         history = node._construct_messages(
-            {
-                "messages": [
+            AssistantState(
+                messages=[
                     HumanMessage(content="Text"),
                     FailureMessage(content="Error"),
                     HumanMessage(content="Text"),
                 ],
-                "plan": "randomplan",
-            },
+                plan="randomplan",
+            ),
         )
         self.assertEqual(len(history), 3)
         self.assertEqual(history[0].type, "human")
@@ -360,19 +405,19 @@ def test_agent_reconstructs_conversation_with_failed_messages(self):
 
     def test_router(self):
         node = DummyGeneratorNode(self.team)
-        state = node.router({"messages": [], "intermediate_steps": None})
+        state = node.router(AssistantState(messages=[], intermediate_steps=None))
         self.assertEqual(state, "next")
         state = node.router(
-            {"messages": [], "intermediate_steps": [(AgentAction(tool="", tool_input="", log=""), None)]}
+            AssistantState(messages=[], intermediate_steps=[(AgentAction(tool="", tool_input="", log=""), None)])
         )
         self.assertEqual(state, "tools")
 
 
-class TestSchemaGeneratorToolsNode(ClickhouseTestMixin, APIBaseTest):
+class TestSchemaGeneratorToolsNode(BaseTest):
     def test_tools_node(self):
         node = SchemaGeneratorToolsNode(self.team)
         action = AgentAction(tool="fix", tool_input="validationerror", log="pydanticexception")
-        state = node.run({"messages": [], "intermediate_steps": [(action, None)]}, {})
-        self.assertIsNotNone("validationerror", state["intermediate_steps"][0][1])
-        self.assertIn("validationerror", state["intermediate_steps"][0][1])
-        self.assertIn("pydanticexception", state["intermediate_steps"][0][1])
+        state = node.run(AssistantState(messages=[], intermediate_steps=[(action, None)]), {})
+        self.assertIsNotNone("validationerror", state.intermediate_steps[0][1])
+        self.assertIn("validationerror", state.intermediate_steps[0][1])
+        self.assertIn("pydanticexception", state.intermediate_steps[0][1])
diff --git a/ee/hogai/summarizer/nodes.py b/ee/hogai/summarizer/nodes.py
index 8d5e8a406f45e..513246bcc1238 100644
--- a/ee/hogai/summarizer/nodes.py
+++ b/ee/hogai/summarizer/nodes.py
@@ -1,15 +1,18 @@
 import json
 from time import sleep
+from uuid import uuid4
+
 from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.runnables import RunnableConfig
 from langchain_openai import ChatOpenAI
-from django.core.serializers.json import DjangoJSONEncoder
 from rest_framework.exceptions import APIException
 from sentry_sdk import capture_exception
 
-from ee.hogai.summarizer.prompts import SUMMARIZER_SYSTEM_PROMPT, SUMMARIZER_INSTRUCTION_PROMPT
-from ee.hogai.utils import AssistantNode, AssistantNodeName, AssistantState
+from ee.hogai.summarizer.prompts import SUMMARIZER_INSTRUCTION_PROMPT, SUMMARIZER_SYSTEM_PROMPT
+from ee.hogai.utils.nodes import AssistantNode
+from ee.hogai.utils.types import AssistantNodeName, AssistantState, PartialAssistantState
 from posthog.api.services.query import process_query_dict
 from posthog.clickhouse.client.execute_async import get_query_status
 from posthog.errors import ExposedCHQueryError
@@ -21,8 +24,8 @@
 class SummarizerNode(AssistantNode):
     name = AssistantNodeName.SUMMARIZER
 
-    def run(self, state: AssistantState, config: RunnableConfig):
-        viz_message = state["messages"][-1]
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
+        viz_message = state.messages[-1]
         if not isinstance(viz_message, VisualizationMessage):
             raise ValueError("Can only run summarization with a visualization message as the last one in the state")
         if viz_message.answer is None:
@@ -58,10 +61,16 @@ def run(self, state: AssistantState, config: RunnableConfig):
                     err_message = ", ".join(f"{key}: {value}" for key, value in err.detail.items())
                 elif isinstance(err.detail, list):
                     err_message = ", ".join(map(str, err.detail))
-            return {"messages": [FailureMessage(content=f"There was an error running this query: {err_message}")]}
+            return PartialAssistantState(
+                messages=[
+                    FailureMessage(content=f"There was an error running this query: {err_message}", id=str(uuid4()))
+                ]
+            )
         except Exception as err:
             capture_exception(err)
-            return {"messages": [FailureMessage(content="There was an unknown error running this query.")]}
+            return PartialAssistantState(
+                messages=[FailureMessage(content="There was an unknown error running this query.", id=str(uuid4()))]
+            )
 
         summarization_prompt = ChatPromptTemplate(self._construct_messages(state), template_format="mustache")
 
@@ -76,7 +85,7 @@ def run(self, state: AssistantState, config: RunnableConfig):
             config,
         )
 
-        return {"messages": [AssistantMessage(content=str(message.content), done=True)]}
+        return PartialAssistantState(messages=[AssistantMessage(content=str(message.content), id=str(uuid4()))])
 
     @property
     def _model(self):
@@ -85,7 +94,7 @@ def _model(self):
     def _construct_messages(self, state: AssistantState) -> list[tuple[str, str]]:
         conversation: list[tuple[str, str]] = [("system", SUMMARIZER_SYSTEM_PROMPT)]
 
-        for message in state.get("messages", []):
+        for message in state.messages:
             if isinstance(message, HumanMessage):
                 conversation.append(("human", message.content))
             elif isinstance(message, AssistantMessage):
diff --git a/ee/hogai/summarizer/test/test_nodes.py b/ee/hogai/summarizer/test/test_nodes.py
index b38d88275aa19..9c54517717b5f 100644
--- a/ee/hogai/summarizer/test/test_nodes.py
+++ b/ee/hogai/summarizer/test/test_nodes.py
@@ -1,23 +1,23 @@
 from unittest.mock import patch
 
 from django.test import override_settings
-from langchain_core.runnables import RunnableLambda
 from langchain_core.messages import (
     HumanMessage as LangchainHumanMessage,
 )
+from langchain_core.runnables import RunnableLambda
+from rest_framework.exceptions import ValidationError
+
 from ee.hogai.summarizer.nodes import SummarizerNode
 from ee.hogai.summarizer.prompts import SUMMARIZER_INSTRUCTION_PROMPT, SUMMARIZER_SYSTEM_PROMPT
+from ee.hogai.utils.types import AssistantState
+from posthog.api.services.query import process_query_dict
 from posthog.schema import (
-    AssistantMessage,
     AssistantTrendsEventsNode,
     AssistantTrendsQuery,
-    FailureMessage,
     HumanMessage,
     VisualizationMessage,
 )
-from rest_framework.exceptions import ValidationError
 from posthog.test.base import APIBaseTest, ClickhouseTestMixin
-from posthog.api.services.query import process_query_dict
 
 
 @override_settings(IN_UNIT_TESTING=True)
@@ -32,28 +32,26 @@ def test_node_runs(self, mock_process_query_dict):
                 lambda _: LangchainHumanMessage(content="The results indicate foobar.")
             )
             new_state = node.run(
-                {
-                    "messages": [
-                        HumanMessage(content="Text"),
+                AssistantState(
+                    messages=[
+                        HumanMessage(content="Text", id="test"),
                         VisualizationMessage(
                             answer=AssistantTrendsQuery(series=[AssistantTrendsEventsNode()]),
                             plan="Plan",
-                            done=True,
+                            id="test2",
+                            initiator="test",
                         ),
                     ],
-                    "plan": "Plan",
-                },
+                    plan="Plan",
+                    start_id="test",
+                ),
                 {},
             )
             mock_process_query_dict.assert_called_once()  # Query processing started
-            self.assertEqual(
-                new_state,
-                {
-                    "messages": [
-                        AssistantMessage(content="The results indicate foobar.", done=True),
-                    ],
-                },
-            )
+            msg = new_state.messages[0]
+            self.assertEqual(msg.content, "The results indicate foobar.")
+            self.assertEqual(msg.type, "ai")
+            self.assertIsNotNone(msg.id)
 
     @patch(
         "ee.hogai.summarizer.nodes.process_query_dict",
@@ -66,28 +64,26 @@ def test_node_handles_internal_error(self, mock_process_query_dict):
                 lambda _: LangchainHumanMessage(content="The results indicate foobar.")
             )
             new_state = node.run(
-                {
-                    "messages": [
-                        HumanMessage(content="Text"),
+                AssistantState(
+                    messages=[
+                        HumanMessage(content="Text", id="test"),
                         VisualizationMessage(
                             answer=AssistantTrendsQuery(series=[AssistantTrendsEventsNode()]),
                             plan="Plan",
-                            done=True,
+                            id="test2",
+                            initiator="test",
                         ),
                     ],
-                    "plan": "Plan",
-                },
+                    plan="Plan",
+                    start_id="test",
+                ),
                 {},
             )
             mock_process_query_dict.assert_called_once()  # Query processing started
-            self.assertEqual(
-                new_state,
-                {
-                    "messages": [
-                        FailureMessage(content="There was an unknown error running this query."),
-                    ],
-                },
-            )
+            msg = new_state.messages[0]
+            self.assertEqual(msg.content, "There was an unknown error running this query.")
+            self.assertEqual(msg.type, "ai/failure")
+            self.assertIsNotNone(msg.id)
 
     @patch(
         "ee.hogai.summarizer.nodes.process_query_dict",
@@ -102,33 +98,29 @@ def test_node_handles_exposed_error(self, mock_process_query_dict):
                 lambda _: LangchainHumanMessage(content="The results indicate foobar.")
             )
             new_state = node.run(
-                {
-                    "messages": [
-                        HumanMessage(content="Text"),
+                AssistantState(
+                    messages=[
+                        HumanMessage(content="Text", id="test"),
                         VisualizationMessage(
                             answer=AssistantTrendsQuery(series=[AssistantTrendsEventsNode()]),
                             plan="Plan",
-                            done=True,
+                            id="test2",
+                            initiator="test",
                         ),
                     ],
-                    "plan": "Plan",
-                },
+                    plan="Plan",
+                    start_id="test",
+                ),
                 {},
             )
             mock_process_query_dict.assert_called_once()  # Query processing started
+            msg = new_state.messages[0]
             self.assertEqual(
-                new_state,
-                {
-                    "messages": [
-                        FailureMessage(
-                            content=(
-                                "There was an error running this query: This query exceeds the capabilities of our picolator. "
-                                "Try de-brolling its flim-flam."
-                            )
-                        ),
-                    ],
-                },
+                msg.content,
+                "There was an error running this query: This query exceeds the capabilities of our picolator. Try de-brolling its flim-flam.",
             )
+            self.assertEqual(msg.type, "ai/failure")
+            self.assertIsNotNone(msg.id)
 
     def test_node_requires_a_viz_message_in_state(self):
         node = SummarizerNode(self.team)
@@ -137,12 +129,13 @@ def test_node_requires_a_viz_message_in_state(self):
             ValueError, "Can only run summarization with a visualization message as the last one in the state"
         ):
             node.run(
-                {
-                    "messages": [
+                AssistantState(
+                    messages=[
                         HumanMessage(content="Text"),
                     ],
-                    "plan": "Plan",
-                },
+                    plan="Plan",
+                    start_id="test",
+                ),
                 {},
             )
 
@@ -151,16 +144,13 @@ def test_node_requires_viz_message_in_state_to_have_query(self):
 
         with self.assertRaisesMessage(ValueError, "Did not found query in the visualization message"):
             node.run(
-                {
-                    "messages": [
-                        VisualizationMessage(
-                            answer=None,
-                            plan="Plan",
-                            done=True,
-                        ),
+                AssistantState(
+                    messages=[
+                        VisualizationMessage(answer=None, plan="Plan", id="test"),
                     ],
-                    "plan": "Plan",
-                },
+                    plan="Plan",
+                    start_id="test",
+                ),
                 {},
             )
 
@@ -170,16 +160,18 @@ def test_agent_reconstructs_conversation(self):
         node = SummarizerNode(self.team)
 
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="What's the trends in signups?"),
+            AssistantState(
+                messages=[
+                    HumanMessage(content="What's the trends in signups?", id="test"),
                     VisualizationMessage(
                         answer=AssistantTrendsQuery(series=[AssistantTrendsEventsNode()]),
                         plan="Plan",
-                        done=True,
+                        id="test2",
+                        initiator="test",
                     ),
-                ]
-            }
+                ],
+                start_id="test",
+            )
         )
         self.assertEqual(
             history,
diff --git a/ee/hogai/taxonomy_agent/nodes.py b/ee/hogai/taxonomy_agent/nodes.py
index d499269a8ca95..bd26a7a93918f 100644
--- a/ee/hogai/taxonomy_agent/nodes.py
+++ b/ee/hogai/taxonomy_agent/nodes.py
@@ -1,4 +1,3 @@
-import itertools
 import xml.etree.ElementTree as ET
 from abc import ABC
 from functools import cached_property
@@ -7,10 +6,16 @@
 from git import Optional
 from langchain.agents.format_scratchpad import format_log_to_str
 from langchain_core.agents import AgentAction
-from langchain_core.messages import AIMessage as LangchainAssistantMessage, BaseMessage, merge_message_runs
+from langchain_core.messages import (
+    AIMessage as LangchainAssistantMessage,
+    BaseMessage,
+    HumanMessage as LangchainHumanMessage,
+    merge_message_runs,
+)
 from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
 from langchain_core.runnables import RunnableConfig
 from langchain_openai import ChatOpenAI
+from langgraph.errors import NodeInterrupt
 from pydantic import ValidationError
 
 from ee.hogai.taxonomy import CORE_FILTER_DEFINITIONS_BY_GROUP
@@ -24,6 +29,7 @@
     REACT_FOLLOW_UP_PROMPT,
     REACT_FORMAT_PROMPT,
     REACT_FORMAT_REMINDER_PROMPT,
+    REACT_HUMAN_IN_THE_LOOP_PROMPT,
     REACT_MALFORMED_JSON_PROMPT,
     REACT_MISSING_ACTION_CORRECTION_PROMPT,
     REACT_MISSING_ACTION_PROMPT,
@@ -33,13 +39,18 @@
     REACT_USER_PROMPT,
 )
 from ee.hogai.taxonomy_agent.toolkit import TaxonomyAgentTool, TaxonomyAgentToolkit
-from ee.hogai.utils import AssistantNode, AssistantState, filter_visualization_conversation, remove_line_breaks
+from ee.hogai.utils.helpers import filter_messages, remove_line_breaks, slice_messages_to_conversation_start
+from ee.hogai.utils.nodes import AssistantNode
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.hogql_queries.ai.team_taxonomy_query_runner import TeamTaxonomyQueryRunner
 from posthog.hogql_queries.query_runner import ExecutionMode
 from posthog.models.group_type_mapping import GroupTypeMapping
 from posthog.schema import (
+    AssistantMessage,
     CachedTeamTaxonomyQueryResponse,
+    HumanMessage,
     TeamTaxonomyQuery,
+    VisualizationMessage,
 )
 
 
@@ -50,8 +61,8 @@ def _run_with_prompt_and_toolkit(
         prompt: ChatPromptTemplate,
         toolkit: TaxonomyAgentToolkit,
         config: Optional[RunnableConfig] = None,
-    ) -> AssistantState:
-        intermediate_steps = state.get("intermediate_steps") or []
+    ) -> PartialAssistantState:
+        intermediate_steps = state.intermediate_steps or []
         conversation = (
             prompt
             + ChatPromptTemplate.from_messages(
@@ -79,6 +90,7 @@ def _run_with_prompt_and_toolkit(
                         "react_format": self._get_react_format_prompt(toolkit),
                         "react_format_reminder": REACT_FORMAT_REMINDER_PROMPT,
                         "react_property_filters": self._get_react_property_filters_prompt(),
+                        "react_human_in_the_loop": REACT_HUMAN_IN_THE_LOOP_PROMPT,
                         "product_description": self._team.project.product_description,
                         "groups": self._team_group_types,
                         "events": self._events_prompt,
@@ -108,12 +120,12 @@ def _run_with_prompt_and_toolkit(
                     e.llm_output,
                 )
 
-        return {
-            "intermediate_steps": [*intermediate_steps, (result, None)],
-        }
+        return PartialAssistantState(
+            intermediate_steps=[*intermediate_steps, (result, None)],
+        )
 
     def router(self, state: AssistantState):
-        if state.get("intermediate_steps", []):
+        if state.intermediate_steps:
             return "tools"
         raise ValueError("Invalid state.")
 
@@ -179,7 +191,7 @@ def _events_prompt(self) -> str:
     @cached_property
     def _team_group_types(self) -> list[str]:
         return list(
-            GroupTypeMapping.objects.filter(team=self._team)
+            GroupTypeMapping.objects.filter(project_id=self._team.project_id)
             .order_by("group_type_index")
             .values_list("group_type", flat=True)
         )
@@ -188,33 +200,34 @@ def _construct_messages(self, state: AssistantState) -> list[BaseMessage]:
         """
         Reconstruct the conversation for the agent. On this step we only care about previously asked questions and generated plans. All other messages are filtered out.
         """
-        human_messages, visualization_messages = filter_visualization_conversation(state.get("messages", []))
-
-        if not human_messages:
-            return []
-
+        start_id = state.start_id
+        filtered_messages = filter_messages(slice_messages_to_conversation_start(state.messages, start_id))
         conversation = []
 
-        for idx, messages in enumerate(itertools.zip_longest(human_messages, visualization_messages)):
-            human_message, viz_message = messages
-
-            if human_message:
+        for idx, message in enumerate(filtered_messages):
+            if isinstance(message, HumanMessage):
+                # Add initial instructions.
                 if idx == 0:
                     conversation.append(
                         HumanMessagePromptTemplate.from_template(REACT_USER_PROMPT, template_format="mustache").format(
-                            question=human_message.content
+                            question=message.content
                         )
                     )
-                else:
+                # Add follow-up instructions only for the human message that initiated a generation.
+                elif message.id == start_id:
                     conversation.append(
                         HumanMessagePromptTemplate.from_template(
                             REACT_FOLLOW_UP_PROMPT,
                             template_format="mustache",
-                        ).format(feedback=human_message.content)
+                        ).format(feedback=message.content)
                     )
-
-            if viz_message:
-                conversation.append(LangchainAssistantMessage(content=viz_message.plan or ""))
+                # Everything else leave as is.
+                else:
+                    conversation.append(LangchainHumanMessage(content=message.content))
+            elif isinstance(message, VisualizationMessage):
+                conversation.append(LangchainAssistantMessage(content=message.plan or ""))
+            elif isinstance(message, AssistantMessage):
+                conversation.append(LangchainAssistantMessage(content=message.content))
 
         return conversation
 
@@ -230,26 +243,37 @@ def _get_agent_scratchpad(self, scratchpad: list[tuple[AgentAction, str | None]]
 class TaxonomyAgentPlannerToolsNode(AssistantNode, ABC):
     def _run_with_toolkit(
         self, state: AssistantState, toolkit: TaxonomyAgentToolkit, config: Optional[RunnableConfig] = None
-    ) -> AssistantState:
-        intermediate_steps = state.get("intermediate_steps") or []
-        action, _ = intermediate_steps[-1]
+    ) -> PartialAssistantState:
+        intermediate_steps = state.intermediate_steps or []
+        action, observation = intermediate_steps[-1]
 
         try:
             input = TaxonomyAgentTool.model_validate({"name": action.tool, "arguments": action.tool_input}).root
         except ValidationError as e:
-            observation = (
+            observation = str(
                 ChatPromptTemplate.from_template(REACT_PYDANTIC_VALIDATION_EXCEPTION_PROMPT, template_format="mustache")
                 .format_messages(exception=e.errors(include_url=False))[0]
                 .content
             )
-            return {"intermediate_steps": [*intermediate_steps[:-1], (action, str(observation))]}
+            return PartialAssistantState(
+                intermediate_steps=[*intermediate_steps[:-1], (action, str(observation))],
+            )
 
         # The plan has been found. Move to the generation.
         if input.name == "final_answer":
-            return {
-                "plan": input.arguments,
-                "intermediate_steps": None,
-            }
+            return PartialAssistantState(
+                plan=input.arguments,
+                intermediate_steps=[],
+            )
+        if input.name == "ask_user_for_help":
+            # The agent has requested help, so we interrupt the graph.
+            if not observation:
+                raise NodeInterrupt(input.arguments)
+
+            # Feedback was provided.
+            return PartialAssistantState(
+                intermediate_steps=[*intermediate_steps[:-1], (action, observation)],
+            )
 
         output = ""
         if input.name == "retrieve_event_properties":
@@ -263,9 +287,11 @@ def _run_with_toolkit(
         else:
             output = toolkit.handle_incorrect_response(input.arguments)
 
-        return {"intermediate_steps": [*intermediate_steps[:-1], (action, output)]}
+        return PartialAssistantState(
+            intermediate_steps=[*intermediate_steps[:-1], (action, output)],
+        )
 
     def router(self, state: AssistantState):
-        if state.get("plan") is not None:
+        if state.plan is not None:
             return "plan_found"
         return "continue"
diff --git a/ee/hogai/taxonomy_agent/prompts.py b/ee/hogai/taxonomy_agent/prompts.py
index f63a7dfe15455..c9d409bcdf103 100644
--- a/ee/hogai/taxonomy_agent/prompts.py
+++ b/ee/hogai/taxonomy_agent/prompts.py
@@ -81,6 +81,15 @@
 </property_filters>
 """.strip()
 
+REACT_HUMAN_IN_THE_LOOP_PROMPT = """
+<human_in_the_loop>
+Ask the user for clarification if:
+- The user's question is ambiguous.
+- You can't find matching events or properties.
+- You're unable to build a plan that effectively answers the user's question.
+</human_in_the_loop>
+""".strip()
+
 REACT_FORMAT_REMINDER_PROMPT = """
 Begin! Reminder that you must ALWAYS respond with a valid JSON blob of a single action. Use tools if necessary. Respond directly if appropriate. Format is Action:```$JSON_BLOB``` then Observation.
 """.strip()
diff --git a/ee/hogai/taxonomy_agent/test/test_nodes.py b/ee/hogai/taxonomy_agent/test/test_nodes.py
index 40127c19370b6..cb25331664331 100644
--- a/ee/hogai/taxonomy_agent/test/test_nodes.py
+++ b/ee/hogai/taxonomy_agent/test/test_nodes.py
@@ -11,7 +11,7 @@
     TaxonomyAgentPlannerToolsNode,
 )
 from ee.hogai.taxonomy_agent.toolkit import TaxonomyAgentToolkit, ToolkitTool
-from ee.hogai.utils import AssistantState
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.models import GroupTypeMapping
 from posthog.schema import (
     AssistantMessage,
@@ -37,7 +37,7 @@ def setUp(self):
 
     def _get_node(self):
         class Node(TaxonomyAgentPlannerNode):
-            def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+            def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
                 prompt: ChatPromptTemplate = ChatPromptTemplate.from_messages([("user", "test")])
                 toolkit = DummyToolkit(self._team)
                 return super()._run_with_prompt_and_toolkit(state, prompt, toolkit, config=config)
@@ -46,19 +46,20 @@ def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
 
     def test_agent_reconstructs_conversation(self):
         node = self._get_node()
-        history = node._construct_messages({"messages": [HumanMessage(content="Text")]})
+        history = node._construct_messages(AssistantState(messages=[HumanMessage(content="Text")]))
         self.assertEqual(len(history), 1)
         self.assertEqual(history[0].type, "human")
         self.assertIn("Text", history[0].content)
         self.assertNotIn(f"{{question}}", history[0].content)
 
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="Text"),
-                    VisualizationMessage(answer=self.schema, plan="randomplan"),
-                ]
-            }
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Text", id="0"),
+                    VisualizationMessage(answer=self.schema, plan="randomplan", id="1", initiator="0"),
+                ],
+                start_id="1",
+            )
         )
         self.assertEqual(len(history), 2)
         self.assertEqual(history[0].type, "human")
@@ -68,13 +69,14 @@ def test_agent_reconstructs_conversation(self):
         self.assertEqual(history[1].content, "randomplan")
 
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="Text"),
-                    VisualizationMessage(answer=self.schema, plan="randomplan"),
-                    HumanMessage(content="Text"),
-                ]
-            }
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Text", id="0"),
+                    VisualizationMessage(answer=self.schema, plan="randomplan", id="1", initiator="0"),
+                    HumanMessage(content="Text", id="2"),
+                ],
+                start_id="2",
+            )
         )
         self.assertEqual(len(history), 3)
         self.assertEqual(history[0].type, "human")
@@ -89,12 +91,14 @@ def test_agent_reconstructs_conversation(self):
     def test_agent_reconstructs_conversation_and_omits_unknown_messages(self):
         node = self._get_node()
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="Text"),
-                    AssistantMessage(content="test"),
-                ]
-            }
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Text", id="0"),
+                    RouterMessage(content="trends", id="1"),
+                    AssistantMessage(content="test", id="2"),
+                ],
+                start_id="0",
+            )
         )
         self.assertEqual(len(history), 1)
         self.assertEqual(history[0].type, "human")
@@ -104,13 +108,13 @@ def test_agent_reconstructs_conversation_and_omits_unknown_messages(self):
     def test_agent_reconstructs_conversation_with_failures(self):
         node = self._get_node()
         history = node._construct_messages(
-            {
-                "messages": [
+            AssistantState(
+                messages=[
                     HumanMessage(content="Text"),
                     FailureMessage(content="Error"),
                     HumanMessage(content="Text"),
-                ]
-            }
+                ],
+            )
         )
         self.assertEqual(len(history), 1)
         self.assertEqual(history[0].type, "human")
@@ -120,32 +124,60 @@ def test_agent_reconstructs_conversation_with_failures(self):
     def test_agent_reconstructs_typical_conversation(self):
         node = self._get_node()
         history = node._construct_messages(
-            {
-                "messages": [
-                    HumanMessage(content="Question 1"),
-                    RouterMessage(content="trends"),
-                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 1"),
-                    AssistantMessage(content="Summary 1"),
-                    HumanMessage(content="Question 2"),
-                    RouterMessage(content="funnel"),
-                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 2"),
-                    AssistantMessage(content="Summary 2"),
-                    HumanMessage(content="Question 3"),
-                    RouterMessage(content="funnel"),
-                ]
-            }
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Question 1", id="0"),
+                    RouterMessage(content="trends", id="1"),
+                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 1", id="2", initiator="0"),
+                    AssistantMessage(content="Summary 1", id="3"),
+                    HumanMessage(content="Question 2", id="4"),
+                    RouterMessage(content="funnel", id="5"),
+                    AssistantMessage(content="Loop 1", id="6"),
+                    HumanMessage(content="Loop Answer 1", id="7"),
+                    VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 2", id="8", initiator="4"),
+                    AssistantMessage(content="Summary 2", id="9"),
+                    HumanMessage(content="Question 3", id="10"),
+                    RouterMessage(content="funnel", id="11"),
+                ],
+                start_id="10",
+            )
         )
-        self.assertEqual(len(history), 5)
+        self.assertEqual(len(history), 9)
         self.assertEqual(history[0].type, "human")
         self.assertIn("Question 1", history[0].content)
         self.assertEqual(history[1].type, "ai")
         self.assertEqual(history[1].content, "Plan 1")
-        self.assertEqual(history[2].type, "human")
-        self.assertIn("Question 2", history[2].content)
-        self.assertEqual(history[3].type, "ai")
-        self.assertEqual(history[3].content, "Plan 2")
-        self.assertEqual(history[4].type, "human")
-        self.assertIn("Question 3", history[4].content)
+        self.assertEqual(history[2].type, "ai")
+        self.assertEqual(history[2].content, "Summary 1")
+        self.assertEqual(history[3].type, "human")
+        self.assertIn("Question 2", history[3].content)
+        self.assertEqual(history[4].type, "ai")
+        self.assertEqual(history[4].content, "Loop 1")
+        self.assertEqual(history[5].type, "human")
+        self.assertEqual(history[5].content, "Loop Answer 1")
+        self.assertEqual(history[6].content, "Plan 2")
+        self.assertEqual(history[6].type, "ai")
+        self.assertEqual(history[7].type, "ai")
+        self.assertEqual(history[7].content, "Summary 2")
+        self.assertEqual(history[8].type, "human")
+        self.assertIn("Question 3", history[8].content)
+
+    def test_agent_reconstructs_conversation_without_messages_after_parent(self):
+        node = self._get_node()
+        history = node._construct_messages(
+            AssistantState(
+                messages=[
+                    HumanMessage(content="Question 1", id="0"),
+                    RouterMessage(content="trends", id="1"),
+                    AssistantMessage(content="Loop 1", id="2"),
+                    HumanMessage(content="Loop Answer 1", id="3"),
+                ],
+                start_id="0",
+            )
+        )
+        self.assertEqual(len(history), 1)
+        self.assertEqual(history[0].type, "human")
+        self.assertIn("Question 1", history[0].content)
 
     def test_agent_filters_out_low_count_events(self):
         _create_person(distinct_ids=["test"], team=self.team)
@@ -182,9 +214,9 @@ def test_agent_handles_output_without_action_block(self):
             return_value=RunnableLambda(lambda _: LangchainAIMessage(content="I don't want to output an action.")),
         ):
             node = self._get_node()
-            state_update = node.run({"messages": [HumanMessage(content="Question")]}, {})
-            self.assertEqual(len(state_update["intermediate_steps"]), 1)
-            action, obs = state_update["intermediate_steps"][0]
+            state_update = node.run(AssistantState(messages=[HumanMessage(content="Question")]), {})
+            self.assertEqual(len(state_update.intermediate_steps), 1)
+            action, obs = state_update.intermediate_steps[0]
             self.assertIsNone(obs)
             self.assertIn("I don't want to output an action.", action.log)
             self.assertIn("Action:", action.log)
@@ -196,9 +228,9 @@ def test_agent_handles_output_with_malformed_json(self):
             return_value=RunnableLambda(lambda _: LangchainAIMessage(content="Thought.\nAction: abc")),
         ):
             node = self._get_node()
-            state_update = node.run({"messages": [HumanMessage(content="Question")]}, {})
-            self.assertEqual(len(state_update["intermediate_steps"]), 1)
-            action, obs = state_update["intermediate_steps"][0]
+            state_update = node.run(AssistantState(messages=[HumanMessage(content="Question")]), {})
+            self.assertEqual(len(state_update.intermediate_steps), 1)
+            action, obs = state_update.intermediate_steps[0]
             self.assertIsNone(obs)
             self.assertIn("Thought.\nAction: abc", action.log)
             self.assertIn("action", action.tool_input)
@@ -232,34 +264,34 @@ def test_property_filters_prompt(self):
 class TestTaxonomyAgentPlannerToolsNode(ClickhouseTestMixin, APIBaseTest):
     def _get_node(self):
         class Node(TaxonomyAgentPlannerToolsNode):
-            def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+            def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
                 toolkit = DummyToolkit(self._team)
                 return super()._run_with_toolkit(state, toolkit, config=config)
 
         return Node(self.team)
 
     def test_node_handles_action_name_validation_error(self):
-        state = {
-            "intermediate_steps": [(AgentAction(tool="does not exist", tool_input="input", log="log"), "test")],
-            "messages": [],
-        }
+        state = AssistantState(
+            intermediate_steps=[(AgentAction(tool="does not exist", tool_input="input", log="log"), "test")],
+            messages=[],
+        )
         node = self._get_node()
         state_update = node.run(state, {})
-        self.assertEqual(len(state_update["intermediate_steps"]), 1)
-        action, observation = state_update["intermediate_steps"][0]
+        self.assertEqual(len(state_update.intermediate_steps), 1)
+        action, observation = state_update.intermediate_steps[0]
         self.assertIsNotNone(observation)
         self.assertIn("<pydantic_exception>", observation)
 
     def test_node_handles_action_input_validation_error(self):
-        state = {
-            "intermediate_steps": [
+        state = AssistantState(
+            intermediate_steps=[
                 (AgentAction(tool="retrieve_entity_property_values", tool_input="input", log="log"), "test")
             ],
-            "messages": [],
-        }
+            messages=[],
+        )
         node = self._get_node()
         state_update = node.run(state, {})
-        self.assertEqual(len(state_update["intermediate_steps"]), 1)
-        action, observation = state_update["intermediate_steps"][0]
+        self.assertEqual(len(state_update.intermediate_steps), 1)
+        action, observation = state_update.intermediate_steps[0]
         self.assertIsNotNone(observation)
         self.assertIn("<pydantic_exception>", observation)
diff --git a/ee/hogai/taxonomy_agent/toolkit.py b/ee/hogai/taxonomy_agent/toolkit.py
index 2af39253b9e68..d05b6f0c933ef 100644
--- a/ee/hogai/taxonomy_agent/toolkit.py
+++ b/ee/hogai/taxonomy_agent/toolkit.py
@@ -55,6 +55,7 @@ class SingleArgumentTaxonomyAgentTool(BaseModel):
         "retrieve_event_properties",
         "final_answer",
         "handle_incorrect_response",
+        "ask_user_for_help",
     ]
     arguments: str
 
@@ -145,6 +146,16 @@ def _default_tools(self) -> list[ToolkitTool]:
                         property_name: The name of the property that you want to retrieve values for.
                 """,
             },
+            {
+                "name": "ask_user_for_help",
+                "signature": "(question: str)",
+                "description": """
+                    Use this tool to ask a question to the user. Your question must be concise and clear.
+
+                    Args:
+                        question: The question you want to ask.
+                """,
+            },
         ]
 
     def render_text_description(self) -> str:
@@ -169,7 +180,7 @@ def render_text_description(self) -> str:
 
     @property
     def _groups(self):
-        return GroupTypeMapping.objects.filter(team=self._team).order_by("group_type_index")
+        return GroupTypeMapping.objects.filter(project_id=self._team.project_id).order_by("group_type_index")
 
     @cached_property
     def _entity_names(self) -> list[str]:
diff --git a/ee/hogai/test/test_assistant.py b/ee/hogai/test/test_assistant.py
index b6cd65bd4ec12..6d0bb8807d629 100644
--- a/ee/hogai/test/test_assistant.py
+++ b/ee/hogai/test/test_assistant.py
@@ -1,31 +1,63 @@
 import json
-from typing import Any
+from typing import Any, Optional, cast
 from unittest.mock import patch
-from uuid import uuid4
-from ee.hogai.utils import Conversation
-from posthog.schema import AssistantMessage, HumanMessage
-from ..assistant import Assistant
+
+from langchain_core import messages
+from langchain_core.agents import AgentAction
+from langchain_core.runnables import RunnableConfig, RunnableLambda
 from langgraph.graph.state import CompiledStateGraph
+from langgraph.types import StateSnapshot
+from pydantic import BaseModel
+
+from ee.models.assistant import Conversation
+from posthog.schema import AssistantMessage, HumanMessage, ReasoningMessage
+from posthog.test.base import NonAtomicBaseTest
+
+from ..assistant import Assistant
 from ..graph import AssistantGraph, AssistantNodeName
-from posthog.test.base import BaseTest
-from langchain_core.agents import AgentAction
 
 
-class TestAssistant(BaseTest):
-    def _run_assistant_graph(self, test_graph: CompiledStateGraph) -> list[tuple[str, Any]]:
+class TestAssistant(NonAtomicBaseTest):
+    CLASS_DATA_LEVEL_SETUP = False
+
+    def setUp(self):
+        super().setUp()
+        self.conversation = Conversation.objects.create(team=self.team, user=self.user)
+
+    def _run_assistant_graph(
+        self,
+        test_graph: Optional[CompiledStateGraph] = None,
+        message: Optional[str] = "Hello",
+        conversation: Optional[Conversation] = None,
+        is_new_conversation: bool = False,
+    ) -> list[tuple[str, Any]]:
         # Create assistant instance with our test graph
         assistant = Assistant(
-            team=self.team,
-            conversation=Conversation(messages=[HumanMessage(content="Hello")], session_id=str(uuid4())),
+            self.team,
+            conversation or self.conversation,
+            HumanMessage(content=message),
+            self.user,
+            is_new_conversation=is_new_conversation,
         )
-        assistant._graph = test_graph
+        if test_graph:
+            assistant._graph = test_graph
         # Capture and parse output of assistant.stream()
         output: list[tuple[str, Any]] = []
         for message in assistant.stream():
-            event_line, data_line, *_ = message.split("\n")
+            event_line, data_line, *_ = cast(str, message).split("\n")
             output.append((event_line.removeprefix("event: "), json.loads(data_line.removeprefix("data: "))))
         return output
 
+    def assertConversationEqual(self, output: list[tuple[str, Any]], expected_output: list[tuple[str, Any]]):
+        for i, ((output_msg_type, output_msg), (expected_msg_type, expected_msg)) in enumerate(
+            zip(output, expected_output)
+        ):
+            self.assertEqual(output_msg_type, expected_msg_type, f"Message type mismatch at index {i}")
+            msg_dict = (
+                expected_msg.model_dump(exclude_none=True) if isinstance(expected_msg, BaseModel) else expected_msg
+            )
+            self.assertDictContainsSubset(msg_dict, output_msg, f"Message content mismatch at index {i}")
+
     @patch(
         "ee.hogai.trends.nodes.TrendsPlannerNode.run",
         return_value={"intermediate_steps": [(AgentAction(tool="final_answer", tool_input="", log=""), None)]},
@@ -39,19 +71,22 @@ def test_reasoning_messages_added(self, _mock_summarizer_run, _mock_funnel_plann
             .add_edge(AssistantNodeName.START, AssistantNodeName.TRENDS_PLANNER)
             .add_trends_planner(AssistantNodeName.SUMMARIZER)
             .add_summarizer(AssistantNodeName.END)
-            .compile()
+            .compile(),
+            conversation=self.conversation,
         )
 
         # Assert that ReasoningMessages are added
-        assert output == [
-            ("status", {"type": "ack"}),
+        expected_output = [
+            (
+                "message",
+                HumanMessage(content="Hello").model_dump(exclude_none=True),
+            ),
             (
                 "message",
                 {
                     "type": "ai/reasoning",
                     "content": "Picking relevant events and properties",  # For TrendsPlannerNode
                     "substeps": [],
-                    "done": True,
                 },
             ),
             (
@@ -60,7 +95,6 @@ def test_reasoning_messages_added(self, _mock_summarizer_run, _mock_funnel_plann
                     "type": "ai/reasoning",
                     "content": "Picking relevant events and properties",  # For TrendsPlannerToolsNode
                     "substeps": [],
-                    "done": True,
                 },
             ),
             (
@@ -71,6 +105,7 @@ def test_reasoning_messages_added(self, _mock_summarizer_run, _mock_funnel_plann
                 },
             ),
         ]
+        self.assertConversationEqual(output, expected_output)
 
     @patch(
         "ee.hogai.trends.nodes.TrendsPlannerNode.run",
@@ -105,19 +140,22 @@ def test_reasoning_messages_with_substeps_added(self, _mock_funnel_planner_run):
             AssistantGraph(self.team)
             .add_edge(AssistantNodeName.START, AssistantNodeName.TRENDS_PLANNER)
             .add_trends_planner(AssistantNodeName.END)
-            .compile()
+            .compile(),
+            conversation=self.conversation,
         )
 
         # Assert that ReasoningMessages are added
-        assert output == [
-            ("status", {"type": "ack"}),
+        expected_output = [
+            (
+                "message",
+                HumanMessage(content="Hello").model_dump(exclude_none=True),
+            ),
             (
                 "message",
                 {
                     "type": "ai/reasoning",
                     "content": "Picking relevant events and properties",  # For TrendsPlannerNode
                     "substeps": [],
-                    "done": True,
                 },
             ),
             (
@@ -131,7 +169,153 @@ def test_reasoning_messages_with_substeps_added(self, _mock_funnel_planner_run):
                         "Analyzing `currency` event's property `purchase`",
                         "Analyzing person property `country_of_birth`",
                     ],
-                    "done": True,
                 },
             ),
         ]
+        self.assertConversationEqual(output, expected_output)
+
+    def _test_human_in_the_loop(self, graph: CompiledStateGraph):
+        with patch("ee.hogai.taxonomy_agent.nodes.TaxonomyAgentPlannerNode._model") as mock:
+            config: RunnableConfig = {
+                "configurable": {
+                    "thread_id": self.conversation.id,
+                }
+            }
+
+            # Interrupt the graph
+            message = """
+            Thought: Let's ask for help.
+            Action:
+            ```
+            {
+                "action": "ask_user_for_help",
+                "action_input": "Need help with this query"
+            }
+            ```
+            """
+            mock.return_value = RunnableLambda(lambda _: messages.AIMessage(content=message))
+            output = self._run_assistant_graph(graph, conversation=self.conversation)
+            expected_output = [
+                ("message", HumanMessage(content="Hello")),
+                ("message", ReasoningMessage(content="Picking relevant events and properties", substeps=[])),
+                ("message", ReasoningMessage(content="Picking relevant events and properties", substeps=[])),
+                ("message", AssistantMessage(content="Need help with this query")),
+            ]
+            self.assertConversationEqual(output, expected_output)
+            snapshot: StateSnapshot = graph.get_state(config)
+            self.assertTrue(snapshot.next)
+            self.assertIn("intermediate_steps", snapshot.values)
+
+            # Resume the graph from the interruption point.
+            message = """
+            Thought: Finish.
+            Action:
+            ```
+            {
+                "action": "final_answer",
+                "action_input": "Plan"
+            }
+            ```
+            """
+            mock.return_value = RunnableLambda(lambda _: messages.AIMessage(content=message))
+            output = self._run_assistant_graph(graph, conversation=self.conversation, message="It's straightforward")
+            expected_output = [
+                ("message", HumanMessage(content="It's straightforward")),
+                ("message", ReasoningMessage(content="Picking relevant events and properties", substeps=[])),
+                ("message", ReasoningMessage(content="Picking relevant events and properties", substeps=[])),
+            ]
+            self.assertConversationEqual(output, expected_output)
+            snapshot: StateSnapshot = graph.get_state(config)
+            self.assertFalse(snapshot.next)
+            self.assertEqual(snapshot.values.get("intermediate_steps"), [])
+            self.assertEqual(snapshot.values["plan"], "Plan")
+
+    def test_trends_interrupt_when_asking_for_help(self):
+        graph = (
+            AssistantGraph(self.team)
+            .add_edge(AssistantNodeName.START, AssistantNodeName.TRENDS_PLANNER)
+            .add_trends_planner(AssistantNodeName.END)
+            .compile()
+        )
+        self._test_human_in_the_loop(graph)
+
+    def test_funnels_interrupt_when_asking_for_help(self):
+        graph = (
+            AssistantGraph(self.team)
+            .add_edge(AssistantNodeName.START, AssistantNodeName.FUNNEL_PLANNER)
+            .add_funnel_planner(AssistantNodeName.END)
+            .compile()
+        )
+        self._test_human_in_the_loop(graph)
+
+    def test_intermediate_steps_are_updated_after_feedback(self):
+        with patch("ee.hogai.taxonomy_agent.nodes.TaxonomyAgentPlannerNode._model") as mock:
+            graph = (
+                AssistantGraph(self.team)
+                .add_edge(AssistantNodeName.START, AssistantNodeName.TRENDS_PLANNER)
+                .add_trends_planner(AssistantNodeName.END)
+                .compile()
+            )
+            config: RunnableConfig = {
+                "configurable": {
+                    "thread_id": self.conversation.id,
+                }
+            }
+
+            # Interrupt the graph
+            message = """
+            Thought: Let's ask for help.
+            Action:
+            ```
+            {
+                "action": "ask_user_for_help",
+                "action_input": "Need help with this query"
+            }
+            ```
+            """
+            mock.return_value = RunnableLambda(lambda _: messages.AIMessage(content=message))
+            self._run_assistant_graph(graph, conversation=self.conversation)
+            snapshot: StateSnapshot = graph.get_state(config)
+            self.assertTrue(snapshot.next)
+            self.assertIn("intermediate_steps", snapshot.values)
+            self.assertEqual(len(snapshot.values["intermediate_steps"]), 1)
+            action, observation = snapshot.values["intermediate_steps"][0]
+            self.assertEqual(action.tool, "ask_user_for_help")
+            self.assertIsNone(observation)
+
+            self._run_assistant_graph(graph, conversation=self.conversation, message="It's straightforward")
+            snapshot: StateSnapshot = graph.get_state(config)
+            self.assertTrue(snapshot.next)
+            self.assertIn("intermediate_steps", snapshot.values)
+            self.assertEqual(len(snapshot.values["intermediate_steps"]), 2)
+            action, observation = snapshot.values["intermediate_steps"][0]
+            self.assertEqual(action.tool, "ask_user_for_help")
+            self.assertEqual(observation, "It's straightforward")
+            action, observation = snapshot.values["intermediate_steps"][1]
+            self.assertEqual(action.tool, "ask_user_for_help")
+            self.assertIsNone(observation)
+
+    def test_new_conversation_handles_serialized_conversation(self):
+        graph = (
+            AssistantGraph(self.team)
+            .add_node(AssistantNodeName.ROUTER, lambda _: {"messages": [AssistantMessage(content="Hello")]})
+            .add_edge(AssistantNodeName.START, AssistantNodeName.ROUTER)
+            .add_edge(AssistantNodeName.ROUTER, AssistantNodeName.END)
+            .compile()
+        )
+        output = self._run_assistant_graph(
+            graph,
+            conversation=self.conversation,
+            is_new_conversation=True,
+        )
+        expected_output = [
+            ("conversation", {"id": str(self.conversation.id)}),
+        ]
+        self.assertConversationEqual(output[:1], expected_output)
+
+        output = self._run_assistant_graph(
+            graph,
+            conversation=self.conversation,
+            is_new_conversation=False,
+        )
+        self.assertNotEqual(output[0][0], "conversation")
diff --git a/ee/hogai/test/test_utils.py b/ee/hogai/test/test_utils.py
index 42e54d058c556..8c32471c88508 100644
--- a/ee/hogai/test/test_utils.py
+++ b/ee/hogai/test/test_utils.py
@@ -1,6 +1,4 @@
-from langchain_core.messages import HumanMessage as LangchainHumanMessage
-
-from ee.hogai.utils import filter_visualization_conversation, merge_human_messages
+from ee.hogai.utils.helpers import filter_messages
 from posthog.schema import (
     AssistantMessage,
     AssistantTrendsQuery,
@@ -13,40 +11,29 @@
 
 
 class TestTrendsUtils(BaseTest):
-    def test_merge_human_messages(self):
-        res = merge_human_messages(
-            [
-                LangchainHumanMessage(content="Text"),
-                LangchainHumanMessage(content="Text"),
-                LangchainHumanMessage(content="Te"),
-                LangchainHumanMessage(content="xt"),
-            ]
-        )
-        self.assertEqual(len(res), 1)
-        self.assertEqual(res, [LangchainHumanMessage(content="Text\nTe\nxt")])
-
-    def test_filter_trends_conversation(self):
-        human_messages, visualization_messages = filter_visualization_conversation(
+    def test_filters_and_merges_human_messages(self):
+        conversation = [
+            HumanMessage(content="Text"),
+            FailureMessage(content="Error"),
+            HumanMessage(content="Text"),
+            VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="plan"),
+            HumanMessage(content="Text2"),
+            VisualizationMessage(answer=None, plan="plan"),
+        ]
+        messages = filter_messages(conversation)
+        self.assertEqual(len(messages), 4)
+        self.assertEqual(
             [
-                HumanMessage(content="Text"),
-                FailureMessage(content="Error"),
-                HumanMessage(content="Text"),
+                HumanMessage(content="Text\nText"),
                 VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="plan"),
                 HumanMessage(content="Text2"),
                 VisualizationMessage(answer=None, plan="plan"),
-            ]
-        )
-        self.assertEqual(len(human_messages), 2)
-        self.assertEqual(len(visualization_messages), 1)
-        self.assertEqual(
-            human_messages, [LangchainHumanMessage(content="Text"), LangchainHumanMessage(content="Text2")]
-        )
-        self.assertEqual(
-            visualization_messages, [VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="plan")]
+            ],
+            messages,
         )
 
     def test_filters_typical_conversation(self):
-        human_messages, visualization_messages = filter_visualization_conversation(
+        messages = filter_messages(
             [
                 HumanMessage(content="Question 1"),
                 RouterMessage(content="trends"),
@@ -58,15 +45,30 @@ def test_filters_typical_conversation(self):
                 AssistantMessage(content="Summary 2"),
             ]
         )
-        self.assertEqual(len(human_messages), 2)
-        self.assertEqual(len(visualization_messages), 2)
-        self.assertEqual(
-            human_messages, [LangchainHumanMessage(content="Question 1"), LangchainHumanMessage(content="Question 2")]
-        )
+        self.assertEqual(len(messages), 6)
         self.assertEqual(
-            visualization_messages,
+            messages,
             [
+                HumanMessage(content="Question 1"),
                 VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 1"),
+                AssistantMessage(content="Summary 1"),
+                HumanMessage(content="Question 2"),
                 VisualizationMessage(answer=AssistantTrendsQuery(series=[]), plan="Plan 2"),
+                AssistantMessage(content="Summary 2"),
+            ],
+        )
+
+    def test_joins_human_messages(self):
+        messages = filter_messages(
+            [
+                HumanMessage(content="Question 1"),
+                HumanMessage(content="Question 2"),
+            ]
+        )
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(
+            messages,
+            [
+                HumanMessage(content="Question 1\nQuestion 2"),
             ],
         )
diff --git a/ee/hogai/trends/nodes.py b/ee/hogai/trends/nodes.py
index b6b33cf6d8354..e430b4036e043 100644
--- a/ee/hogai/trends/nodes.py
+++ b/ee/hogai/trends/nodes.py
@@ -6,12 +6,12 @@
 from ee.hogai.taxonomy_agent.nodes import TaxonomyAgentPlannerNode, TaxonomyAgentPlannerToolsNode
 from ee.hogai.trends.prompts import REACT_SYSTEM_PROMPT, TRENDS_SYSTEM_PROMPT
 from ee.hogai.trends.toolkit import TRENDS_SCHEMA, TrendsTaxonomyAgentToolkit
-from ee.hogai.utils import AssistantState
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.schema import AssistantTrendsQuery
 
 
 class TrendsPlannerNode(TaxonomyAgentPlannerNode):
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         toolkit = TrendsTaxonomyAgentToolkit(self._team)
         prompt = ChatPromptTemplate.from_messages(
             [
@@ -23,7 +23,7 @@ def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
 
 
 class TrendsPlannerToolsNode(TaxonomyAgentPlannerToolsNode):
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         toolkit = TrendsTaxonomyAgentToolkit(self._team)
         return super()._run_with_toolkit(state, toolkit, config=config)
 
@@ -36,7 +36,7 @@ class TrendsGeneratorNode(SchemaGeneratorNode[AssistantTrendsQuery]):
     OUTPUT_MODEL = TrendsSchemaGeneratorOutput
     OUTPUT_SCHEMA = TRENDS_SCHEMA
 
-    def run(self, state: AssistantState, config: RunnableConfig) -> AssistantState:
+    def run(self, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
         prompt = ChatPromptTemplate.from_messages(
             [
                 ("system", TRENDS_SYSTEM_PROMPT),
diff --git a/ee/hogai/trends/prompts.py b/ee/hogai/trends/prompts.py
index 2ac9496480cdd..dcc1daeaa5a00 100644
--- a/ee/hogai/trends/prompts.py
+++ b/ee/hogai/trends/prompts.py
@@ -12,6 +12,8 @@
 {{react_format}}
 </agent_info>
 
+{{react_human_in_the_loop}}
+
 Below you will find information on how to correctly discover the taxonomy of the user's data.
 
 <general_knowledge>
diff --git a/ee/hogai/trends/test/test_nodes.py b/ee/hogai/trends/test/test_nodes.py
index 44973b3195377..369ce8bc9b292 100644
--- a/ee/hogai/trends/test/test_nodes.py
+++ b/ee/hogai/trends/test/test_nodes.py
@@ -4,6 +4,7 @@
 from langchain_core.runnables import RunnableLambda
 
 from ee.hogai.trends.nodes import TrendsGeneratorNode, TrendsSchemaGeneratorOutput
+from ee.hogai.utils.types import AssistantState, PartialAssistantState
 from posthog.schema import (
     AssistantTrendsQuery,
     HumanMessage,
@@ -17,6 +18,7 @@ class TestTrendsGeneratorNode(ClickhouseTestMixin, APIBaseTest):
     maxDiff = None
 
     def setUp(self):
+        super().setUp()
         self.schema = AssistantTrendsQuery(series=[])
 
     def test_node_runs(self):
@@ -26,16 +28,16 @@ def test_node_runs(self):
                 lambda _: TrendsSchemaGeneratorOutput(query=self.schema).model_dump()
             )
             new_state = node.run(
-                {
-                    "messages": [HumanMessage(content="Text")],
-                    "plan": "Plan",
-                },
+                AssistantState(
+                    messages=[HumanMessage(content="Text")],
+                    plan="Plan",
+                ),
                 {},
             )
             self.assertEqual(
                 new_state,
-                {
-                    "messages": [VisualizationMessage(answer=self.schema, plan="Plan", done=True)],
-                    "intermediate_steps": None,
-                },
+                PartialAssistantState(
+                    messages=[VisualizationMessage(answer=self.schema, plan="Plan", id=new_state.messages[0].id)],
+                    intermediate_steps=None,
+                ),
             )
diff --git a/ee/hogai/trends/toolkit.py b/ee/hogai/trends/toolkit.py
index d69830d2f2cd6..5fd7a35f0f18a 100644
--- a/ee/hogai/trends/toolkit.py
+++ b/ee/hogai/trends/toolkit.py
@@ -1,8 +1,6 @@
 from ee.hogai.taxonomy_agent.toolkit import TaxonomyAgentToolkit, ToolkitTool
-from ee.hogai.utils import dereference_schema
-from posthog.schema import (
-    AssistantTrendsQuery,
-)
+from ee.hogai.utils.helpers import dereference_schema
+from posthog.schema import AssistantTrendsQuery
 
 
 class TrendsTaxonomyAgentToolkit(TaxonomyAgentToolkit):
diff --git a/ee/hogai/utils.py b/ee/hogai/utils.py
deleted file mode 100644
index 278e2f4076495..0000000000000
--- a/ee/hogai/utils.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import operator
-from abc import ABC, abstractmethod
-from collections.abc import Sequence
-from enum import StrEnum
-from typing import Annotated, Optional, TypedDict, Union
-
-from jsonref import replace_refs
-from langchain_core.agents import AgentAction
-from langchain_core.messages import (
-    HumanMessage as LangchainHumanMessage,
-    merge_message_runs,
-)
-from langchain_core.runnables import RunnableConfig
-from langgraph.graph import END, START
-from pydantic import BaseModel, Field
-
-from posthog.models.team.team import Team
-from posthog.schema import (
-    AssistantMessage,
-    FailureMessage,
-    HumanMessage,
-    ReasoningMessage,
-    RootAssistantMessage,
-    RouterMessage,
-    VisualizationMessage,
-)
-
-AssistantMessageUnion = Union[
-    AssistantMessage, HumanMessage, VisualizationMessage, FailureMessage, RouterMessage, ReasoningMessage
-]
-
-
-class Conversation(BaseModel):
-    messages: list[RootAssistantMessage] = Field(..., min_length=1, max_length=20)
-    session_id: str
-
-
-class AssistantState(TypedDict, total=False):
-    messages: Annotated[Sequence[AssistantMessageUnion], operator.add]
-    intermediate_steps: Optional[list[tuple[AgentAction, Optional[str]]]]
-    plan: Optional[str]
-
-
-class AssistantNodeName(StrEnum):
-    START = START
-    END = END
-    ROUTER = "router"
-    TRENDS_PLANNER = "trends_planner"
-    TRENDS_PLANNER_TOOLS = "trends_planner_tools"
-    TRENDS_GENERATOR = "trends_generator"
-    TRENDS_GENERATOR_TOOLS = "trends_generator_tools"
-    FUNNEL_PLANNER = "funnel_planner"
-    FUNNEL_PLANNER_TOOLS = "funnel_planner_tools"
-    FUNNEL_GENERATOR = "funnel_generator"
-    FUNNEL_GENERATOR_TOOLS = "funnel_generator_tools"
-    SUMMARIZER = "summarizer"
-
-
-class AssistantNode(ABC):
-    _team: Team
-
-    def __init__(self, team: Team):
-        self._team = team
-
-    @abstractmethod
-    def run(cls, state: AssistantState, config: RunnableConfig) -> AssistantState:
-        raise NotImplementedError
-
-
-def remove_line_breaks(line: str) -> str:
-    return line.replace("\n", " ")
-
-
-def merge_human_messages(messages: list[LangchainHumanMessage]) -> list[LangchainHumanMessage]:
-    """
-    Filters out duplicated human messages and merges them into one message.
-    """
-    contents = set()
-    filtered_messages = []
-    for message in messages:
-        if message.content in contents:
-            continue
-        contents.add(message.content)
-        filtered_messages.append(message)
-    return merge_message_runs(filtered_messages)
-
-
-def filter_visualization_conversation(
-    messages: Sequence[AssistantMessageUnion],
-) -> tuple[list[LangchainHumanMessage], list[VisualizationMessage]]:
-    """
-    Splits, filters and merges the message history to be consumable by agents. Returns human and visualization messages.
-    """
-    stack: list[LangchainHumanMessage] = []
-    human_messages: list[LangchainHumanMessage] = []
-    visualization_messages: list[VisualizationMessage] = []
-
-    for message in messages:
-        if isinstance(message, HumanMessage):
-            stack.append(LangchainHumanMessage(content=message.content))
-        elif isinstance(message, VisualizationMessage) and message.answer:
-            if stack:
-                human_messages += merge_human_messages(stack)
-                stack = []
-            visualization_messages.append(message)
-
-    if stack:
-        human_messages += merge_human_messages(stack)
-
-    return human_messages, visualization_messages
-
-
-def dereference_schema(schema: dict) -> dict:
-    new_schema: dict = replace_refs(schema, proxies=False, lazy_load=False)
-    if "$defs" in new_schema:
-        new_schema.pop("$defs")
-    return new_schema
diff --git a/ee/hogai/utils/__init__.py b/ee/hogai/utils/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/ee/hogai/utils/helpers.py b/ee/hogai/utils/helpers.py
new file mode 100644
index 0000000000000..4fc8cf3b5d6a0
--- /dev/null
+++ b/ee/hogai/utils/helpers.py
@@ -0,0 +1,79 @@
+from collections.abc import Sequence
+from typing import Optional, TypeVar, Union
+
+from jsonref import replace_refs
+from langchain_core.messages import (
+    HumanMessage as LangchainHumanMessage,
+    merge_message_runs,
+)
+
+from posthog.schema import (
+    AssistantMessage,
+    HumanMessage,
+    VisualizationMessage,
+)
+
+from .types import AIMessageUnion, AssistantMessageUnion
+
+
+def remove_line_breaks(line: str) -> str:
+    return line.replace("\n", " ")
+
+
+def filter_messages(
+    messages: Sequence[AssistantMessageUnion],
+    entity_filter: Union[tuple[type[AIMessageUnion], ...], type[AIMessageUnion]] = (
+        AssistantMessage,
+        VisualizationMessage,
+    ),
+) -> list[AssistantMessageUnion]:
+    """
+    Filters and merges the message history to be consumable by agents. Returns human and AI messages.
+    """
+    stack: list[LangchainHumanMessage] = []
+    filtered_messages: list[AssistantMessageUnion] = []
+
+    def _merge_stack(stack: list[LangchainHumanMessage]) -> list[HumanMessage]:
+        return [
+            HumanMessage(content=langchain_message.content, id=langchain_message.id)
+            for langchain_message in merge_message_runs(stack)
+        ]
+
+    for message in messages:
+        if isinstance(message, HumanMessage):
+            stack.append(LangchainHumanMessage(content=message.content, id=message.id))
+        elif isinstance(message, entity_filter):
+            if stack:
+                filtered_messages += _merge_stack(stack)
+                stack = []
+            filtered_messages.append(message)
+
+    if stack:
+        filtered_messages += _merge_stack(stack)
+
+    return filtered_messages
+
+
+T = TypeVar("T", bound=AssistantMessageUnion)
+
+
+def find_last_message_of_type(messages: Sequence[AssistantMessageUnion], message_type: type[T]) -> Optional[T]:
+    return next((msg for msg in reversed(messages) if isinstance(msg, message_type)), None)
+
+
+def slice_messages_to_conversation_start(
+    messages: Sequence[AssistantMessageUnion], start_id: Optional[str] = None
+) -> Sequence[AssistantMessageUnion]:
+    result = []
+    for msg in messages:
+        result.append(msg)
+        if msg.id == start_id:
+            break
+    return result
+
+
+def dereference_schema(schema: dict) -> dict:
+    new_schema: dict = replace_refs(schema, proxies=False, lazy_load=False)
+    if "$defs" in new_schema:
+        new_schema.pop("$defs")
+    return new_schema
diff --git a/ee/hogai/utils/nodes.py b/ee/hogai/utils/nodes.py
new file mode 100644
index 0000000000000..6a4358243b666
--- /dev/null
+++ b/ee/hogai/utils/nodes.py
@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+
+from langchain_core.runnables import RunnableConfig
+
+from posthog.models.team.team import Team
+
+from .types import AssistantState, PartialAssistantState
+
+
+class AssistantNode(ABC):
+    _team: Team
+
+    def __init__(self, team: Team):
+        self._team = team
+
+    @abstractmethod
+    def run(cls, state: AssistantState, config: RunnableConfig) -> PartialAssistantState:
+        raise NotImplementedError
diff --git a/ee/hogai/utils/state.py b/ee/hogai/utils/state.py
new file mode 100644
index 0000000000000..3392f3362adb9
--- /dev/null
+++ b/ee/hogai/utils/state.py
@@ -0,0 +1,70 @@
+from typing import Any, Literal, TypedDict, TypeGuard, Union
+
+from langchain_core.messages import AIMessageChunk
+
+from ee.hogai.utils.types import AssistantNodeName, AssistantState, PartialAssistantState
+
+# A state update can have a partial state or a LangGraph's reserved dataclasses like Interrupt.
+GraphValueUpdate = dict[AssistantNodeName, dict[Any, Any] | Any]
+
+GraphValueUpdateTuple = tuple[Literal["values"], GraphValueUpdate]
+
+
+def is_value_update(update: list[Any]) -> TypeGuard[GraphValueUpdateTuple]:
+    """
+    Transition between nodes.
+
+    Returns:
+        PartialAssistantState, Interrupt, or other LangGraph reserved dataclasses.
+    """
+    return len(update) == 2 and update[0] == "updates"
+
+
+def validate_value_update(update: GraphValueUpdate) -> dict[AssistantNodeName, PartialAssistantState | Any]:
+    validated_update = {}
+    for node_name, value in update.items():
+        if isinstance(value, dict):
+            validated_update[node_name] = PartialAssistantState.model_validate(value)
+        else:
+            validated_update[node_name] = value
+    return validated_update
+
+
+class LangGraphState(TypedDict):
+    langgraph_node: AssistantNodeName
+
+
+GraphMessageUpdateTuple = tuple[Literal["messages"], tuple[Union[AIMessageChunk, Any], LangGraphState]]
+
+
+def is_message_update(update: list[Any]) -> TypeGuard[GraphMessageUpdateTuple]:
+    """
+    Streaming of messages.
+    """
+    return len(update) == 2 and update[0] == "messages"
+
+
+GraphStateUpdateTuple = tuple[Literal["updates"], dict[Any, Any]]
+
+
+def is_state_update(update: list[Any]) -> TypeGuard[GraphStateUpdateTuple]:
+    """
+    Update of the state. Returns a full state.
+    """
+    return len(update) == 2 and update[0] == "values"
+
+
+def validate_state_update(state_update: dict[Any, Any]) -> AssistantState:
+    return AssistantState.model_validate(state_update)
+
+
+GraphTaskStartedUpdateTuple = tuple[Literal["debug"], tuple[Union[AIMessageChunk, Any], LangGraphState]]
+
+
+def is_task_started_update(
+    update: list[Any],
+) -> TypeGuard[GraphTaskStartedUpdateTuple]:
+    """
+    Streaming of messages.
+    """
+    return len(update) == 2 and update[0] == "debug" and update[1]["type"] == "task"
diff --git a/ee/hogai/utils/types.py b/ee/hogai/utils/types.py
new file mode 100644
index 0000000000000..2df027b6f85af
--- /dev/null
+++ b/ee/hogai/utils/types.py
@@ -0,0 +1,52 @@
+import operator
+from collections.abc import Sequence
+from enum import StrEnum
+from typing import Annotated, Optional, Union
+
+from langchain_core.agents import AgentAction
+from langgraph.graph import END, START
+from pydantic import BaseModel, Field
+
+from posthog.schema import (
+    AssistantMessage,
+    FailureMessage,
+    HumanMessage,
+    ReasoningMessage,
+    RouterMessage,
+    VisualizationMessage,
+)
+
+AIMessageUnion = Union[AssistantMessage, VisualizationMessage, FailureMessage, RouterMessage, ReasoningMessage]
+AssistantMessageUnion = Union[HumanMessage, AIMessageUnion]
+
+
+class _SharedAssistantState(BaseModel):
+    intermediate_steps: Optional[list[tuple[AgentAction, Optional[str]]]] = Field(default=None)
+    start_id: Optional[str] = Field(default=None)
+    """
+    The ID of the message from which the conversation started.
+    """
+    plan: Optional[str] = Field(default=None)
+
+
+class AssistantState(_SharedAssistantState):
+    messages: Annotated[Sequence[AssistantMessageUnion], operator.add]
+
+
+class PartialAssistantState(_SharedAssistantState):
+    messages: Optional[Annotated[Sequence[AssistantMessageUnion], operator.add]] = Field(default=None)
+
+
+class AssistantNodeName(StrEnum):
+    START = START
+    END = END
+    ROUTER = "router"
+    TRENDS_PLANNER = "trends_planner"
+    TRENDS_PLANNER_TOOLS = "trends_planner_tools"
+    TRENDS_GENERATOR = "trends_generator"
+    TRENDS_GENERATOR_TOOLS = "trends_generator_tools"
+    FUNNEL_PLANNER = "funnel_planner"
+    FUNNEL_PLANNER_TOOLS = "funnel_planner_tools"
+    FUNNEL_GENERATOR = "funnel_generator"
+    FUNNEL_GENERATOR_TOOLS = "funnel_generator_tools"
+    SUMMARIZER = "summarizer"
diff --git a/ee/management/commands/materialize_columns.py b/ee/management/commands/materialize_columns.py
index c1ca3b3fd2287..6d54f8362ff1d 100644
--- a/ee/management/commands/materialize_columns.py
+++ b/ee/management/commands/materialize_columns.py
@@ -1,3 +1,4 @@
+import argparse
 import logging
 
 from django.core.management.base import BaseCommand
@@ -69,8 +70,14 @@ def add_arguments(self, parser):
             default=MATERIALIZE_COLUMNS_MAX_AT_ONCE,
             help="Max number of columns to materialize via single invocation. Same as MATERIALIZE_COLUMNS_MAX_AT_ONCE env variable.",
         )
+        parser.add_argument(
+            "--nullable",
+            action=argparse.BooleanOptionalAction,
+            default=True,
+            dest="is_nullable",
+        )
 
-    def handle(self, *args, **options):
+    def handle(self, *, is_nullable: bool, **options):
         logger.setLevel(logging.INFO)
 
         if options["dry_run"]:
@@ -80,7 +87,7 @@ def handle(self, *args, **options):
             logger.info(f"Materializing column. table={options['property_table']}, property_name={options['property']}")
 
             materialize_properties_task(
-                columns_to_materialize=[
+                properties_to_materialize=[
                     (
                         options["property_table"],
                         options["table_column"],
@@ -90,6 +97,7 @@ def handle(self, *args, **options):
                 ],
                 backfill_period_days=options["backfill_period"],
                 dry_run=options["dry_run"],
+                is_nullable=is_nullable,
             )
         else:
             materialize_properties_task(
@@ -99,4 +107,5 @@ def handle(self, *args, **options):
                 backfill_period_days=options["backfill_period"],
                 dry_run=options["dry_run"],
                 team_id_to_analyze=options["analyze_team_id"],
+                is_nullable=is_nullable,
             )
diff --git a/ee/management/commands/update_materialized_column.py b/ee/management/commands/update_materialized_column.py
index b45444eb4831b..bb55a61545dd6 100644
--- a/ee/management/commands/update_materialized_column.py
+++ b/ee/management/commands/update_materialized_column.py
@@ -1,7 +1,7 @@
 import logging
 
 from typing import Any
-from collections.abc import Callable
+from collections.abc import Callable, Iterable
 from django.core.management.base import BaseCommand, CommandParser
 
 from posthog.clickhouse.materialized_columns import ColumnName, TablesWithMaterializedColumns
@@ -9,9 +9,9 @@
 
 logger = logging.getLogger(__name__)
 
-COLUMN_OPERATIONS: dict[str, Callable[[TablesWithMaterializedColumns, ColumnName], Any]] = {
-    "enable": lambda table, column_name: update_column_is_disabled(table, column_name, is_disabled=False),
-    "disable": lambda table, column_name: update_column_is_disabled(table, column_name, is_disabled=True),
+COLUMN_OPERATIONS: dict[str, Callable[[TablesWithMaterializedColumns, Iterable[ColumnName]], Any]] = {
+    "enable": lambda table, column_names: update_column_is_disabled(table, column_names, is_disabled=False),
+    "disable": lambda table, column_names: update_column_is_disabled(table, column_names, is_disabled=True),
     "drop": drop_column,
 }
 
@@ -20,10 +20,12 @@ class Command(BaseCommand):
     def add_arguments(self, parser: CommandParser) -> None:
         parser.add_argument("operation", choices=COLUMN_OPERATIONS.keys())
         parser.add_argument("table")
-        parser.add_argument("column_name")
+        parser.add_argument("column_names", nargs="+", metavar="column")
 
-    def handle(self, operation: str, table: TablesWithMaterializedColumns, column_name: ColumnName, **options):
-        logger.info("Running %r for %r.%r...", operation, table, column_name)
+    def handle(
+        self, operation: str, table: TablesWithMaterializedColumns, column_names: Iterable[ColumnName], **options
+    ):
+        logger.info("Running %r on %r for %r...", operation, table, column_names)
         fn = COLUMN_OPERATIONS[operation]
-        fn(table, column_name)
+        fn(table, column_names)
         logger.info("Success!")
diff --git a/ee/migrations/0018_conversation_conversationcheckpoint_and_more.py b/ee/migrations/0018_conversation_conversationcheckpoint_and_more.py
new file mode 100644
index 0000000000000..ec48cc780ad57
--- /dev/null
+++ b/ee/migrations/0018_conversation_conversationcheckpoint_and_more.py
@@ -0,0 +1,147 @@
+# Generated by Django 4.2.15 on 2024-12-11 15:51
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import posthog.models.utils
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("posthog", "0528_project_field_in_taxonomy"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("ee", "0017_accesscontrol_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Conversation",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                ("team", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to="posthog.team")),
+                ("user", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.CreateModel(
+            name="ConversationCheckpoint",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                (
+                    "checkpoint_ns",
+                    models.TextField(
+                        default="",
+                        help_text='Checkpoint namespace. Denotes the path to the subgraph node the checkpoint originates from, separated by `|` character, e.g. `"child|grandchild"`. Defaults to "" (root graph).',
+                    ),
+                ),
+                ("checkpoint", models.JSONField(help_text="Serialized checkpoint data.", null=True)),
+                ("metadata", models.JSONField(help_text="Serialized checkpoint metadata.", null=True)),
+                (
+                    "parent_checkpoint",
+                    models.ForeignKey(
+                        help_text="Parent checkpoint ID.",
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="children",
+                        to="ee.conversationcheckpoint",
+                    ),
+                ),
+                (
+                    "thread",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, related_name="checkpoints", to="ee.conversation"
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ConversationCheckpointWrite",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                ("task_id", models.UUIDField(help_text="Identifier for the task creating the checkpoint write.")),
+                (
+                    "idx",
+                    models.IntegerField(
+                        help_text="Index of the checkpoint write. It is an integer value where negative numbers are reserved for special cases, such as node interruption."
+                    ),
+                ),
+                (
+                    "channel",
+                    models.TextField(
+                        help_text="An arbitrary string defining the channel name. For example, it can be a node name or a reserved LangGraph's enum."
+                    ),
+                ),
+                ("type", models.TextField(help_text="Type of the serialized blob. For example, `json`.", null=True)),
+                ("blob", models.BinaryField(null=True)),
+                (
+                    "checkpoint",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="writes",
+                        to="ee.conversationcheckpoint",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ConversationCheckpointBlob",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                (
+                    "channel",
+                    models.TextField(
+                        help_text="An arbitrary string defining the channel name. For example, it can be a node name or a reserved LangGraph's enum."
+                    ),
+                ),
+                ("version", models.TextField(help_text="Monotonically increasing version of the channel.")),
+                ("type", models.TextField(help_text="Type of the serialized blob. For example, `json`.", null=True)),
+                ("blob", models.BinaryField(null=True)),
+                (
+                    "checkpoint",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="blobs",
+                        to="ee.conversationcheckpoint",
+                    ),
+                ),
+            ],
+        ),
+        migrations.AddConstraint(
+            model_name="conversationcheckpointwrite",
+            constraint=models.UniqueConstraint(
+                fields=("checkpoint_id", "task_id", "idx"), name="unique_checkpoint_write"
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="conversationcheckpointblob",
+            constraint=models.UniqueConstraint(
+                fields=("checkpoint_id", "channel", "version"), name="unique_checkpoint_blob"
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="conversationcheckpoint",
+            constraint=models.UniqueConstraint(fields=("id", "checkpoint_ns", "thread"), name="unique_checkpoint"),
+        ),
+    ]
diff --git a/ee/migrations/max_migration.txt b/ee/migrations/max_migration.txt
index 449d87290c304..fb889f1cc34cf 100644
--- a/ee/migrations/max_migration.txt
+++ b/ee/migrations/max_migration.txt
@@ -1 +1 @@
-0017_accesscontrol_and_more
+0018_conversation_conversationcheckpoint_and_more
diff --git a/ee/models/__init__.py b/ee/models/__init__.py
index df7cfcba704e6..2067d11f7618f 100644
--- a/ee/models/__init__.py
+++ b/ee/models/__init__.py
@@ -1,3 +1,4 @@
+from .assistant import Conversation, ConversationCheckpoint, ConversationCheckpointBlob, ConversationCheckpointWrite
 from .dashboard_privilege import DashboardPrivilege
 from .event_definition import EnterpriseEventDefinition
 from .explicit_team_membership import ExplicitTeamMembership
@@ -10,7 +11,11 @@
 
 __all__ = [
     "AccessControl",
+    "ConversationCheckpoint",
+    "ConversationCheckpointBlob",
+    "ConversationCheckpointWrite",
     "DashboardPrivilege",
+    "Conversation",
     "EnterpriseEventDefinition",
     "EnterprisePropertyDefinition",
     "ExplicitTeamMembership",
diff --git a/ee/models/assistant.py b/ee/models/assistant.py
new file mode 100644
index 0000000000000..390a7ab7a117f
--- /dev/null
+++ b/ee/models/assistant.py
@@ -0,0 +1,83 @@
+from collections.abc import Iterable
+
+from django.db import models
+from langgraph.checkpoint.serde.types import TASKS
+
+from posthog.models.team.team import Team
+from posthog.models.user import User
+from posthog.models.utils import UUIDModel
+
+
+class Conversation(UUIDModel):
+    user = models.ForeignKey(User, on_delete=models.CASCADE)
+    team = models.ForeignKey(Team, on_delete=models.CASCADE)
+
+
+class ConversationCheckpoint(UUIDModel):
+    thread = models.ForeignKey(Conversation, on_delete=models.CASCADE, related_name="checkpoints")
+    checkpoint_ns = models.TextField(
+        default="",
+        help_text='Checkpoint namespace. Denotes the path to the subgraph node the checkpoint originates from, separated by `|` character, e.g. `"child|grandchild"`. Defaults to "" (root graph).',
+    )
+    parent_checkpoint = models.ForeignKey(
+        "self", null=True, on_delete=models.CASCADE, related_name="children", help_text="Parent checkpoint ID."
+    )
+    checkpoint = models.JSONField(null=True, help_text="Serialized checkpoint data.")
+    metadata = models.JSONField(null=True, help_text="Serialized checkpoint metadata.")
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["id", "checkpoint_ns", "thread"],
+                name="unique_checkpoint",
+            )
+        ]
+
+    @property
+    def pending_sends(self) -> Iterable["ConversationCheckpointWrite"]:
+        if self.parent_checkpoint is None:
+            return []
+        return self.parent_checkpoint.writes.filter(channel=TASKS).order_by("task_id", "idx")
+
+    @property
+    def pending_writes(self) -> Iterable["ConversationCheckpointWrite"]:
+        return self.writes.order_by("idx", "task_id")
+
+
+class ConversationCheckpointBlob(UUIDModel):
+    checkpoint = models.ForeignKey(ConversationCheckpoint, on_delete=models.CASCADE, related_name="blobs")
+    channel = models.TextField(
+        help_text="An arbitrary string defining the channel name. For example, it can be a node name or a reserved LangGraph's enum."
+    )
+    version = models.TextField(help_text="Monotonically increasing version of the channel.")
+    type = models.TextField(null=True, help_text="Type of the serialized blob. For example, `json`.")
+    blob = models.BinaryField(null=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["checkpoint_id", "channel", "version"],
+                name="unique_checkpoint_blob",
+            )
+        ]
+
+
+class ConversationCheckpointWrite(UUIDModel):
+    checkpoint = models.ForeignKey(ConversationCheckpoint, on_delete=models.CASCADE, related_name="writes")
+    task_id = models.UUIDField(help_text="Identifier for the task creating the checkpoint write.")
+    idx = models.IntegerField(
+        help_text="Index of the checkpoint write. It is an integer value where negative numbers are reserved for special cases, such as node interruption."
+    )
+    channel = models.TextField(
+        help_text="An arbitrary string defining the channel name. For example, it can be a node name or a reserved LangGraph's enum."
+    )
+    type = models.TextField(null=True, help_text="Type of the serialized blob. For example, `json`.")
+    blob = models.BinaryField(null=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["checkpoint_id", "task_id", "idx"],
+                name="unique_checkpoint_write",
+            )
+        ]
diff --git a/ee/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_filters.ambr b/ee/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_filters.ambr
deleted file mode 100644
index 389933177e2ca..0000000000000
--- a/ee/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_filters.ambr
+++ /dev/null
@@ -1,1649 +0,0 @@
-# serializer version: 1
-# name: TestClickhouseSessionRecordingsListFromFilters.test_effect_of_poe_settings_on_query_generated_0_test_poe_v1_still_falls_back_to_person_subquery
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, %(hogql_val_0)s)) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, %(hogql_val_1)s)) AS end_time,
-         dateDiff(%(hogql_val_2)s, start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_13)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 50000
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_effect_of_poe_settings_on_query_generated_1_test_poe_being_unavailable_we_fall_back_to_person_id_overrides
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, %(hogql_val_0)s)) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, %(hogql_val_1)s)) AS end_time,
-         dateDiff(%(hogql_val_2)s, start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, %(hogql_val_8)s), ''), 'null'), '^"|"$', ''), person.version) AS properties___rgInternal, person.id AS id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_9)s), person.version), plus(now64(6, %(hogql_val_10)s), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), now64(6, %(hogql_val_13)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_14)s), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_15)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(events__person.properties___rgInternal, %(hogql_val_16)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 50000
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_effect_of_poe_settings_on_query_generated_2_test_poe_being_unavailable_we_fall_back_to_person_subquery_but_still_use_mat_props
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, %(hogql_val_0)s)) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, %(hogql_val_1)s)) AS end_time,
-         dateDiff(%(hogql_val_2)s, start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, %(hogql_val_8)s), ''), 'null'), '^"|"$', ''), person.version) AS properties___rgInternal, person.id AS id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_9)s), person.version), plus(now64(6, %(hogql_val_10)s), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), now64(6, %(hogql_val_13)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_14)s), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_15)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(events__person.properties___rgInternal, %(hogql_val_16)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 50000
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_effect_of_poe_settings_on_query_generated_3_test_allow_denormalised_props_fix_does_not_stop_all_poe_processing
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, %(hogql_val_0)s)) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, %(hogql_val_1)s)) AS end_time,
-         dateDiff(%(hogql_val_2)s, start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_13)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 50000
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_effect_of_poe_settings_on_query_generated_4_test_poe_v2_available_person_properties_are_used_in_replay_listing
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, %(hogql_val_0)s)) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, %(hogql_val_1)s)) AS end_time,
-         dateDiff(%(hogql_val_2)s, start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_13)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 50000
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_00_poe_v2_and_materialized_columns_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_00_poe_v2_and_materialized_columns_allowed_with_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_01_poe_v2_and_materialized_columns_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_01_poe_v2_and_materialized_columns_allowed_without_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_02_poe_v2_and_materialized_columns_off_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_02_poe_v2_and_materialized_columns_off_with_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_03_poe_v2_and_materialized_columns_off_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_03_poe_v2_and_materialized_columns_off_without_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_04_poe_off_and_materialized_columns_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_04_poe_off_and_materialized_columns_allowed_with_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_05_poe_off_and_materialized_columns_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_05_poe_off_and_materialized_columns_allowed_without_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_06_poe_off_and_materialized_columns_not_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_06_poe_off_and_materialized_columns_not_allowed_with_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_07_poe_off_and_materialized_columns_not_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_07_poe_off_and_materialized_columns_not_allowed_without_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_08_poe_v1_and_materialized_columns_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_08_poe_v1_and_materialized_columns_allowed_with_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_09_poe_v1_and_materialized_columns_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_09_poe_v1_and_materialized_columns_allowed_without_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_10_poe_v1_and_not_materialized_columns_not_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_10_poe_v1_and_not_materialized_columns_not_allowed_with_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_11_poe_v1_and_not_materialized_columns_not_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_event_filter_with_person_properties_materialized_11_poe_v1_and_not_materialized_columns_not_allowed_without_materialization.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_00_poe_v2_and_materialized_columns_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_01_poe_v2_and_materialized_columns_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_02_poe_v2_and_materialized_columns_off_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_03_poe_v2_and_materialized_columns_off_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_04_poe_off_and_materialized_columns_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_05_poe_off_and_materialized_columns_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_06_poe_off_and_materialized_columns_not_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_07_poe_off_and_materialized_columns_not_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_08_poe_v1_and_materialized_columns_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_09_poe_v1_and_materialized_columns_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_10_poe_v1_and_not_materialized_columns_not_allowed_with_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestClickhouseSessionRecordingsListFromFilters.test_person_id_filter_11_poe_v1_and_not_materialized_columns_not_allowed_without_materialization
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
diff --git a/ee/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr b/ee/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr
index bcd1ed1e3c8cb..97bc6424e1cbd 100644
--- a/ee/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr
+++ b/ee/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr
@@ -19,12 +19,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_12)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_12)s), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -51,24 +51,24 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, %(hogql_val_8)s), ''), 'null'), '^"|"$', ''), person.version) AS properties___rgInternal, person.id AS id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_9)s), person.version), plus(now64(6, %(hogql_val_10)s), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), now64(6, %(hogql_val_13)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_14)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___rgInternal, %(hogql_val_15)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, %(hogql_val_8)s), ''), 'null'), '^"|"$', ''), person.version) AS properties___rgInternal, person.id AS id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_9)s), person.version), plus(now64(6, %(hogql_val_10)s), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), now64(6, %(hogql_val_13)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_14)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___rgInternal, %(hogql_val_15)s), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -95,24 +95,24 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, %(hogql_val_8)s), ''), 'null'), '^"|"$', ''), person.version) AS properties___rgInternal, person.id AS id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_9)s), person.version), plus(now64(6, %(hogql_val_10)s), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), now64(6, %(hogql_val_13)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_14)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___rgInternal, %(hogql_val_15)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, %(hogql_val_8)s), ''), 'null'), '^"|"$', ''), person.version) AS properties___rgInternal, person.id AS id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, %(hogql_val_9)s), person.version), plus(now64(6, %(hogql_val_10)s), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_12)s), now64(6, %(hogql_val_13)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_14)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___rgInternal, %(hogql_val_15)s), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -139,12 +139,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_12)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_12)s), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -171,12 +171,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, %(hogql_val_3)s)), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff(%(hogql_val_4)s, start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_12)s), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_5)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_6)s), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, %(hogql_val_7)s), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_8)s), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, %(hogql_val_9)s), now64(6, %(hogql_val_10)s)), greaterOrEquals(toTimeZone(events.timestamp, %(hogql_val_11)s), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null'), %(hogql_val_12)s), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -203,7 +203,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -238,12 +238,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -278,7 +278,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -313,12 +313,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -353,7 +353,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -388,12 +388,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -428,7 +428,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -463,12 +463,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -503,7 +503,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -538,27 +538,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -593,7 +593,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -628,27 +628,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -683,7 +683,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -718,27 +718,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -773,7 +773,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -808,27 +808,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -863,7 +863,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -898,12 +898,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -938,7 +938,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -973,12 +973,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1013,7 +1013,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1048,12 +1048,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1088,7 +1088,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1123,12 +1123,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(mat_pp_email, ''), 'null'), 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1163,10 +1163,10 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1201,10 +1201,10 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1239,10 +1239,10 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1277,10 +1277,10 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), equals(events.person_id, '00000000-0000-0000-0000-000000000000'), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1315,16 +1315,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1359,16 +1359,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1403,16 +1403,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1447,16 +1447,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1491,16 +1491,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1535,16 +1535,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1579,16 +1579,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1623,16 +1623,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
diff --git a/ee/session_recordings/queries/test/test_session_recording_list_from_filters.py b/ee/session_recordings/queries/test/test_session_recording_list_from_filters.py
deleted file mode 100644
index 391d12071966f..0000000000000
--- a/ee/session_recordings/queries/test/test_session_recording_list_from_filters.py
+++ /dev/null
@@ -1,353 +0,0 @@
-import re
-from itertools import product
-from uuid import uuid4
-
-from dateutil.relativedelta import relativedelta
-from django.utils.timezone import now
-from freezegun import freeze_time
-from parameterized import parameterized
-
-from ee.clickhouse.materialized_columns.columns import materialize
-from posthog.clickhouse.client import sync_execute
-from posthog.hogql.ast import CompareOperation, And, SelectQuery
-from posthog.hogql.base import Expr
-from posthog.hogql.context import HogQLContext
-from posthog.hogql.printer import print_ast
-from posthog.models import Person
-from posthog.models.filters import SessionRecordingsFilter
-from posthog.schema import PersonsOnEventsMode
-from posthog.session_recordings.queries.session_recording_list_from_filters import (
-    SessionRecordingListFromFilters,
-)
-from posthog.session_recordings.queries.test.session_replay_sql import produce_replay_summary
-from posthog.session_recordings.sql.session_replay_event_sql import TRUNCATE_SESSION_REPLAY_EVENTS_TABLE_SQL
-from posthog.test.base import (
-    APIBaseTest,
-    ClickhouseTestMixin,
-    QueryMatchingTest,
-    snapshot_clickhouse_queries,
-    _create_event,
-)
-
-
-# The HogQL pair of TestClickhouseSessionRecordingsListFromSessionReplay can be renamed when delete the old one
-@freeze_time("2021-01-01T13:46:23")
-class TestClickhouseSessionRecordingsListFromFilters(ClickhouseTestMixin, APIBaseTest, QueryMatchingTest):
-    def _print_query(self, query: SelectQuery) -> str:
-        return print_ast(
-            query,
-            HogQLContext(team_id=self.team.pk, enable_select_queries=True),
-            "clickhouse",
-            pretty=True,
-        )
-
-    def tearDown(self) -> None:
-        sync_execute(TRUNCATE_SESSION_REPLAY_EVENTS_TABLE_SQL())
-
-    @property
-    def base_time(self):
-        return (now() - relativedelta(hours=1)).replace(microsecond=0, second=0)
-
-    def create_event(
-        self,
-        distinct_id,
-        timestamp,
-        team=None,
-        event_name="$pageview",
-        properties=None,
-    ):
-        if team is None:
-            team = self.team
-        if properties is None:
-            properties = {"$os": "Windows 95", "$current_url": "aloha.com/2"}
-        return _create_event(
-            team=team,
-            event=event_name,
-            timestamp=timestamp,
-            distinct_id=distinct_id,
-            properties=properties,
-        )
-
-    @parameterized.expand(
-        [
-            [
-                "test_poe_v1_still_falls_back_to_person_subquery",
-                True,
-                False,
-                False,
-                PersonsOnEventsMode.PERSON_ID_NO_OVERRIDE_PROPERTIES_ON_EVENTS,
-            ],
-            [
-                "test_poe_being_unavailable_we_fall_back_to_person_id_overrides",
-                False,
-                False,
-                False,
-                PersonsOnEventsMode.PERSON_ID_OVERRIDE_PROPERTIES_JOINED,
-            ],
-            [
-                "test_poe_being_unavailable_we_fall_back_to_person_subquery_but_still_use_mat_props",
-                False,
-                False,
-                False,
-                PersonsOnEventsMode.PERSON_ID_OVERRIDE_PROPERTIES_JOINED,
-            ],
-            [
-                "test_allow_denormalised_props_fix_does_not_stop_all_poe_processing",
-                False,
-                True,
-                False,
-                PersonsOnEventsMode.PERSON_ID_OVERRIDE_PROPERTIES_ON_EVENTS,
-            ],
-            [
-                "test_poe_v2_available_person_properties_are_used_in_replay_listing",
-                False,
-                True,
-                True,
-                PersonsOnEventsMode.PERSON_ID_OVERRIDE_PROPERTIES_ON_EVENTS,
-            ],
-        ]
-    )
-    def test_effect_of_poe_settings_on_query_generated(
-        self,
-        _name: str,
-        poe_v1: bool,
-        poe_v2: bool,
-        allow_denormalized_props: bool,
-        expected_poe_mode: PersonsOnEventsMode,
-    ) -> None:
-        with self.settings(
-            PERSON_ON_EVENTS_OVERRIDE=poe_v1,
-            PERSON_ON_EVENTS_V2_OVERRIDE=poe_v2,
-            ALLOW_DENORMALIZED_PROPS_IN_LISTING=allow_denormalized_props,
-        ):
-            assert self.team.person_on_events_mode == expected_poe_mode
-            materialize("events", "rgInternal", table_column="person_properties")
-
-            filter = SessionRecordingsFilter(
-                team=self.team,
-                data={
-                    "properties": [
-                        {
-                            "key": "rgInternal",
-                            "value": ["false"],
-                            "operator": "exact",
-                            "type": "person",
-                        }
-                    ]
-                },
-            )
-            session_recording_list_instance = SessionRecordingListFromFilters(
-                filter=filter, team=self.team, hogql_query_modifiers=None
-            )
-
-            hogql_parsed_select = session_recording_list_instance.get_query()
-            printed_query = self._print_query(hogql_parsed_select)
-
-            person_filtering_expr = self._matching_person_filter_expr_from(hogql_parsed_select)
-
-            self._assert_is_events_person_filter(person_filtering_expr)
-
-            if poe_v1 or poe_v2:
-                # Property used directly from event (from materialized column)
-                assert "ifNull(equals(nullIf(nullIf(mat_pp_rgInternal, ''), 'null')" in printed_query
-            else:
-                # We get the person property value from the persons JOIN
-                assert re.search(
-                    r"argMax\(replaceRegexpAll\(nullIf\(nullIf\(JSONExtractRaw\(person\.properties, %\(hogql_val_\d+\)s\), ''\), 'null'\), '^\"|\"\$', ''\), person\.version\) AS properties___rgInternal",
-                    printed_query,
-                )
-                # Then we actually filter on that property value
-                assert re.search(
-                    r"ifNull\(equals\(events__person\.properties___rgInternal, %\(hogql_val_\d+\)s\), 0\)",
-                    printed_query,
-                )
-            self.assertQueryMatchesSnapshot(printed_query)
-
-    def _assert_is_pdi_filter(self, person_filtering_expr: list[Expr]) -> None:
-        assert person_filtering_expr[0].right.select_from.table.chain == ["person_distinct_ids"]
-        assert person_filtering_expr[0].right.where.left.chain == ["person", "properties", "rgInternal"]
-
-    def _assert_is_events_person_filter(self, person_filtering_expr: list[Expr]) -> None:
-        assert person_filtering_expr[0].right.select_from.table.chain == ["events"]
-        event_person_condition = [
-            x
-            for x in person_filtering_expr[0].right.where.exprs
-            if isinstance(x, CompareOperation) and x.left.chain == ["person", "properties", "rgInternal"]
-        ]
-        assert len(event_person_condition) == 1
-
-    def _matching_person_filter_expr_from(self, hogql_parsed_select: SelectQuery) -> list[Expr]:
-        where_conditions: list[Expr] = hogql_parsed_select.where.exprs
-        ands = [x for x in where_conditions if isinstance(x, And)]
-        assert len(ands) == 1
-        and_comparisons = [x for x in ands[0].exprs if isinstance(x, CompareOperation)]
-        assert len(and_comparisons) == 1
-        assert isinstance(and_comparisons[0].right, SelectQuery)
-        return and_comparisons
-
-    settings_combinations = [
-        ["poe v2 and materialized columns allowed", False, True, True],
-        ["poe v2 and materialized columns off", False, True, False],
-        ["poe off and materialized columns allowed", False, False, True],
-        ["poe off and materialized columns not allowed", False, False, False],
-        ["poe v1 and materialized columns allowed", True, False, True],
-        ["poe v1 and not materialized columns not allowed", True, False, False],
-    ]
-
-    # Options for "materialize person columns"
-    materialization_options = [
-        [" with materialization", True],
-        [" without materialization", False],
-    ]
-
-    # Expand the parameter list to the product of all combinations with "materialize person columns"
-    # e.g. [a, b] x [c, d] = [a, c], [a, d], [b, c], [b, d]
-    test_case_combinations = [
-        [f"{name}{mat_option}", poe_v1, poe, mat_columns, mat_person]
-        for (name, poe_v1, poe, mat_columns), (mat_option, mat_person) in product(
-            settings_combinations, materialization_options
-        )
-    ]
-
-    @parameterized.expand(test_case_combinations)
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_person_properties_materialized(
-        self,
-        _name: str,
-        poe1_enabled: bool,
-        poe2_enabled: bool,
-        allow_denormalised_props: bool,
-        materialize_person_props: bool,
-    ) -> None:
-        # KLUDGE: I couldn't figure out how to use @also_test_with_materialized_columns(person_properties=["email"])
-        # KLUDGE: and the parameterized.expand decorator at the same time, so we generate test case combos
-        # KLUDGE: for materialization on and off to test both sides the way the decorator would have
-        if materialize_person_props:
-            materialize("events", "email", table_column="person_properties")
-            materialize("person", "email")
-
-        with self.settings(
-            PERSON_ON_EVENTS_OVERRIDE=poe1_enabled,
-            PERSON_ON_EVENTS_V2_OVERRIDE=poe2_enabled,
-            ALLOW_DENORMALIZED_PROPS_IN_LISTING=allow_denormalised_props,
-        ):
-            user_one = "test_event_filter_with_person_properties-user"
-            user_two = "test_event_filter_with_person_properties-user2"
-            session_id_one = f"test_event_filter_with_person_properties-1-{str(uuid4())}"
-            session_id_two = f"test_event_filter_with_person_properties-2-{str(uuid4())}"
-
-            Person.objects.create(team=self.team, distinct_ids=[user_one], properties={"email": "bla"})
-            Person.objects.create(team=self.team, distinct_ids=[user_two], properties={"email": "bla2"})
-
-            self._add_replay_with_pageview(session_id_one, user_one)
-            produce_replay_summary(
-                distinct_id=user_one,
-                session_id=session_id_one,
-                first_timestamp=(self.base_time + relativedelta(seconds=30)),
-                team_id=self.team.id,
-            )
-            self._add_replay_with_pageview(session_id_two, user_two)
-            produce_replay_summary(
-                distinct_id=user_two,
-                session_id=session_id_two,
-                first_timestamp=(self.base_time + relativedelta(seconds=30)),
-                team_id=self.team.id,
-            )
-
-            match_everyone_filter = SessionRecordingsFilter(
-                team=self.team,
-                data={"properties": []},
-            )
-
-            session_recording_list_instance = SessionRecordingListFromFilters(
-                filter=match_everyone_filter, team=self.team, hogql_query_modifiers=None
-            )
-            (session_recordings, _, _) = session_recording_list_instance.run()
-
-            assert sorted([x["session_id"] for x in session_recordings]) == sorted([session_id_one, session_id_two])
-
-            match_bla_filter = SessionRecordingsFilter(
-                team=self.team,
-                data={
-                    "properties": [
-                        {
-                            "key": "email",
-                            "value": ["bla"],
-                            "operator": "exact",
-                            "type": "person",
-                        }
-                    ]
-                },
-            )
-
-            session_recording_list_instance = SessionRecordingListFromFilters(
-                filter=match_bla_filter, team=self.team, hogql_query_modifiers=None
-            )
-            (session_recordings, _, _) = session_recording_list_instance.run()
-
-            assert len(session_recordings) == 1
-            assert session_recordings[0]["session_id"] == session_id_one
-
-    def _add_replay_with_pageview(self, session_id: str, user: str) -> None:
-        self.create_event(
-            user,
-            self.base_time,
-            properties={"$session_id": session_id, "$window_id": str(uuid4())},
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.base_time,
-            team_id=self.team.id,
-        )
-
-    @parameterized.expand(test_case_combinations)
-    @snapshot_clickhouse_queries
-    def test_person_id_filter(
-        self,
-        _name: str,
-        poe2_enabled: bool,
-        poe1_enabled: bool,
-        allow_denormalised_props: bool,
-        materialize_person_props: bool,
-    ) -> None:
-        # KLUDGE: I couldn't figure out how to use @also_test_with_materialized_columns(person_properties=["email"])
-        # KLUDGE: and the parameterized.expand decorator at the same time, so we generate test case combos
-        # KLUDGE: for materialization on and off to test both sides the way the decorator would have
-        if materialize_person_props:
-            # it shouldn't matter to this test whether any column is materialized
-            # but let's keep the tests in this file similar so we flush out any unexpected interactions
-            materialize("events", "email", table_column="person_properties")
-            materialize("person", "email")
-
-        with self.settings(
-            PERSON_ON_EVENTS_OVERRIDE=poe1_enabled,
-            PERSON_ON_EVENTS_V2_OVERRIDE=poe2_enabled,
-            ALLOW_DENORMALIZED_PROPS_IN_LISTING=allow_denormalised_props,
-        ):
-            three_user_ids = ["person-1-distinct-1", "person-1-distinct-2", "person-2"]
-            session_id_one = f"test_person_id_filter-session-one"
-            session_id_two = f"test_person_id_filter-session-two"
-            session_id_three = f"test_person_id_filter-session-three"
-
-            p = Person.objects.create(
-                team=self.team,
-                distinct_ids=[three_user_ids[0], three_user_ids[1]],
-                properties={"email": "bla"},
-            )
-            Person.objects.create(
-                team=self.team,
-                distinct_ids=[three_user_ids[2]],
-                properties={"email": "bla2"},
-            )
-
-            self._add_replay_with_pageview(session_id_one, three_user_ids[0])
-            self._add_replay_with_pageview(session_id_two, three_user_ids[1])
-            self._add_replay_with_pageview(session_id_three, three_user_ids[2])
-
-            filter = SessionRecordingsFilter(team=self.team, data={"person_uuid": str(p.uuid)})
-            session_recording_list_instance = SessionRecordingListFromFilters(
-                filter=filter, team=self.team, hogql_query_modifiers=None
-            )
-            (session_recordings, _, _) = session_recording_list_instance.run()
-            assert sorted([r["session_id"] for r in session_recordings]) == sorted([session_id_two, session_id_one])
diff --git a/ee/session_recordings/session_recording_playlist.py b/ee/session_recordings/session_recording_playlist.py
index a3dc50c1228f5..7b1a962b187b7 100644
--- a/ee/session_recordings/session_recording_playlist.py
+++ b/ee/session_recordings/session_recording_playlist.py
@@ -1,4 +1,3 @@
-import json
 from typing import Any, Optional
 
 import structlog
@@ -13,7 +12,7 @@
 from posthog.api.forbid_destroy_model import ForbidDestroyModel
 from posthog.api.routing import TeamAndOrgViewSetMixin
 from posthog.api.shared import UserBasicSerializer
-from posthog.constants import SESSION_RECORDINGS_FILTER_IDS, AvailableFeature
+from posthog.constants import AvailableFeature
 from posthog.models import (
     SessionRecording,
     SessionRecordingPlaylist,
@@ -27,7 +26,6 @@
     changes_between,
     log_activity,
 )
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
 from posthog.models.team.team import check_is_feature_available_for_team
 from posthog.models.utils import UUIDT
 from posthog.rate_limit import (
@@ -37,7 +35,6 @@
 from posthog.schema import RecordingsQuery
 from posthog.session_recordings.session_recording_api import (
     list_recordings_response,
-    list_recordings,
     query_as_params_to_dict,
     list_recordings_from_query,
 )
@@ -230,19 +227,12 @@ def recordings(self, request: request.Request, *args: Any, **kwargs: Any) -> res
             .values_list("recording_id", flat=True)
         )
 
-        use_query_type = (request.GET.get("as_query", "False")).lower() == "true"
-
-        if use_query_type:
-            data_dict = query_as_params_to_dict(request.GET.dict())
-            query = RecordingsQuery.model_validate(data_dict)
-            query.session_ids = playlist_items
-            return list_recordings_response(
-                list_recordings_from_query(query, request, context=self.get_serializer_context())
-            )
-        else:
-            filter = SessionRecordingsFilter(request=request, team=self.team)
-            filter = filter.shallow_clone({SESSION_RECORDINGS_FILTER_IDS: json.dumps(playlist_items)})
-            return list_recordings_response(list_recordings(filter, request, context=self.get_serializer_context()))
+        data_dict = query_as_params_to_dict(request.GET.dict())
+        query = RecordingsQuery.model_validate(data_dict)
+        query.session_ids = playlist_items
+        return list_recordings_response(
+            list_recordings_from_query(query, request, context=self.get_serializer_context())
+        )
 
     # As of now, you can only "update" a session recording by adding or removing a recording from a static playlist
     @action(
diff --git a/ee/surveys/summaries/summarize_surveys.py b/ee/surveys/summaries/summarize_surveys.py
index 1e4b088484f55..1b74ca04d60c8 100644
--- a/ee/surveys/summaries/summarize_surveys.py
+++ b/ee/surveys/summaries/summarize_surveys.py
@@ -121,7 +121,7 @@ def summarize_survey_responses(
 we're trying to identify what to work on
             use as concise and simple language as is possible.
             generate no text other than the summary.
-            the aim is to let people see themes in the responses received. return the text in github flavoured markdown format""",
+            the aim is to let people see themes in the responses received. return the text in markdown format without using any paragraph formatting""",
                 },
             ],
             user=f"{instance_region}/{user.pk}",
@@ -131,5 +131,7 @@ def summarize_survey_responses(
         if usage:
             TOKENS_IN_PROMPT_HISTOGRAM.observe(usage)
 
+    logger.info("survey_summary_response", result=result)
+
     content: str = result.choices[0].message.content or ""
     return {"content": content, "timings": timer.get_all_timings()}
diff --git a/ee/tasks/materialized_columns.py b/ee/tasks/materialized_columns.py
index d05cdddc0b0ca..98091c3b1d00a 100644
--- a/ee/tasks/materialized_columns.py
+++ b/ee/tasks/materialized_columns.py
@@ -1,50 +1,49 @@
+from collections.abc import Iterator
+from dataclasses import dataclass
 from celery.utils.log import get_task_logger
+from clickhouse_driver import Client
 
-from ee.clickhouse.materialized_columns.columns import (
-    TRIM_AND_EXTRACT_PROPERTY,
-    get_materialized_columns,
-)
+from ee.clickhouse.materialized_columns.columns import MaterializedColumn, get_cluster, tables as table_infos
 from posthog.client import sync_execute
-from posthog.settings import CLICKHOUSE_CLUSTER, CLICKHOUSE_DATABASE
+from posthog.settings import CLICKHOUSE_DATABASE
 from posthog.clickhouse.materialized_columns import ColumnName, TablesWithMaterializedColumns
 
 logger = get_task_logger(__name__)
 
 
-def mark_all_materialized() -> None:
-    if any_ongoing_mutations():
-        logger.info("There are running mutations, skipping marking as materialized")
-        return
-
-    for (
-        table,
-        property_name,
-        table_column,
-        column_name,
-    ) in get_materialized_columns_with_default_expression():
-        updated_table = "sharded_events" if table == "events" else table
-
-        # :TRICKY: On cloud, we ON CLUSTER updates to events/sharded_events but not to persons. Why? ¯\_(ツ)_/¯
-        execute_on_cluster = f"ON CLUSTER '{CLICKHOUSE_CLUSTER}'" if table == "events" else ""
-
-        sync_execute(
-            f"""
-            ALTER TABLE {updated_table}
-            {execute_on_cluster}
-            MODIFY COLUMN
-            {column_name} VARCHAR MATERIALIZED {TRIM_AND_EXTRACT_PROPERTY.format(table_column=table_column)}
-            """,
-            {"property": property_name},
+@dataclass
+class MarkMaterializedTask:
+    table: str
+    column: MaterializedColumn
+
+    def execute(self, client: Client) -> None:
+        expression, parameters = self.column.get_expression_and_parameters()
+        client.execute(
+            f"ALTER TABLE {self.table} MODIFY COLUMN {self.column.name} {self.column.type} MATERIALIZED {expression}",
+            parameters,
         )
 
 
-def get_materialized_columns_with_default_expression():
-    tables: list[TablesWithMaterializedColumns] = ["events", "person"]
-    for table in tables:
-        materialized_columns = get_materialized_columns(table)
-        for (property_name, table_column), column_name in materialized_columns.items():
-            if is_default_expression(table, column_name):
-                yield table, property_name, table_column, column_name
+def mark_all_materialized() -> None:
+    cluster = get_cluster()
+
+    for table_name, column in get_materialized_columns_with_default_expression():
+        table_info = table_infos[table_name]
+        table_info.map_data_nodes(
+            cluster,
+            MarkMaterializedTask(
+                table_info.data_table,
+                column,
+            ).execute,
+        ).result()
+
+
+def get_materialized_columns_with_default_expression() -> Iterator[tuple[str, MaterializedColumn]]:
+    table_names: list[TablesWithMaterializedColumns] = ["events", "person"]
+    for table_name in table_names:
+        for column in MaterializedColumn.get_all(table_name):
+            if is_default_expression(table_name, column.name):
+                yield table_name, column
 
 
 def any_ongoing_mutations() -> bool:
diff --git a/ee/tasks/test/test_calculate_cohort.py b/ee/tasks/test/test_calculate_cohort.py
index c5264bbe12631..ed0dd3e4290cc 100644
--- a/ee/tasks/test/test_calculate_cohort.py
+++ b/ee/tasks/test/test_calculate_cohort.py
@@ -45,6 +45,7 @@ def test_create_stickiness_cohort(self, _insert_cohort_from_insight_filter):
                 "stickiness_days": "1",
                 "label": "$pageview",
             },
+            self.team.pk,
         )
 
         insert_cohort_from_insight_filter(
@@ -118,6 +119,7 @@ def test_create_trends_cohort(self, _insert_cohort_from_insight_filter):
                 "date_to": "2021-01-01",
                 "label": "$pageview",
             },
+            self.team.pk,
         )
         insert_cohort_from_insight_filter(
             cohort_id,
@@ -228,6 +230,7 @@ def test_create_trends_cohort_arg_test(self, _insert_cohort_from_insight_filter)
                 "interval": "day",
                 "properties": '[{"key": "$domain", "value": "app.posthog.com", "operator": "icontains", "type": "event"}]',
             },
+            self.team.pk,
         )
         insert_cohort_from_insight_filter(
             cohort_id,
@@ -357,6 +360,7 @@ def test_create_funnels_cohort(self, _insert_cohort_from_insight_filter):
                 "date_to": "2021-01-07",
                 "funnel_step": "1",
             },
+            self.team.pk,
         )
 
         insert_cohort_from_insight_filter(cohort_id, params)
@@ -445,6 +449,7 @@ def _create_events(data, event="$pageview"):
                 "entity_order": "0",
                 "lifecycle_type": "returning",
             },
+            self.team.pk,
         )
 
         insert_cohort_from_insight_filter(
@@ -507,6 +512,7 @@ def _create_events(data, event="$pageview"):
                 "entity_order": "0",
                 "lifecycle_type": "dormant",
             },
+            self.team.pk,
         )
         self.assertEqual(_insert_cohort_from_insight_filter.call_count, 2)
 
diff --git a/ee/urls.py b/ee/urls.py
index 7c722bc31852f..91b58e0fcb238 100644
--- a/ee/urls.py
+++ b/ee/urls.py
@@ -6,11 +6,11 @@
 from django.urls.conf import path
 
 from ee.api import integration
-from .api.rbac import organization_resource_access, role
 
 from .api import (
     authentication,
     billing,
+    conversation,
     dashboard_collaborator,
     explicit_team_member,
     feature_flag_role_access,
@@ -19,18 +19,20 @@
     sentry_stats,
     subscription,
 )
+from .api.rbac import organization_resource_access, role
 from .session_recordings import session_recording_playlist
 
 
 def extend_api_router() -> None:
     from posthog.api import (
-        router as root_router,
-        register_grandfathered_environment_nested_viewset,
-        projects_router,
-        organizations_router,
-        project_feature_flags_router,
         environment_dashboards_router,
+        environments_router,
         legacy_project_dashboards_router,
+        organizations_router,
+        project_feature_flags_router,
+        projects_router,
+        register_grandfathered_environment_nested_viewset,
+        router as root_router,
     )
 
     root_router.register(r"billing", billing.BillingViewset, "billing")
@@ -93,6 +95,10 @@ def extend_api_router() -> None:
         ["project_id"],
     )
 
+    environments_router.register(
+        r"conversations", conversation.ConversationViewSet, "environment_conversations", ["team_id"]
+    )
+
 
 # The admin interface is disabled on self-hosted instances, as its misuse can be unsafe
 admin_urlpatterns = (
diff --git a/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--dark.png b/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--dark.png
index 1f129b49b9cf8..24cc8f4b2f6b6 100644
Binary files a/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--dark.png and b/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--dark.png differ
diff --git a/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--light.png b/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--light.png
index 3077ca6a36368..64fd850a0fc25 100644
Binary files a/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--light.png and b/frontend/__snapshots__/components-cards-insight-details--data-table-events-query--light.png differ
diff --git a/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--dark.png b/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--dark.png
index 1f129b49b9cf8..24cc8f4b2f6b6 100644
Binary files a/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--dark.png and b/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--dark.png differ
diff --git a/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--light.png b/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--light.png
index 3077ca6a36368..64fd850a0fc25 100644
Binary files a/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--light.png and b/frontend/__snapshots__/components-cards-insight-details--data-table-hog-ql-query--light.png differ
diff --git a/frontend/__snapshots__/components-cards-text-card--template--dark.png b/frontend/__snapshots__/components-cards-text-card--template--dark.png
index 1418925cf2961..08005be3d11b8 100644
Binary files a/frontend/__snapshots__/components-cards-text-card--template--dark.png and b/frontend/__snapshots__/components-cards-text-card--template--dark.png differ
diff --git a/frontend/__snapshots__/components-cards-text-card--template--light.png b/frontend/__snapshots__/components-cards-text-card--template--light.png
index c0961d67af400..fdd4b64968096 100644
Binary files a/frontend/__snapshots__/components-cards-text-card--template--light.png and b/frontend/__snapshots__/components-cards-text-card--template--light.png differ
diff --git a/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--dark.png b/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--dark.png
index 5865d3715d1a6..fcbc4ceb12a2a 100644
Binary files a/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--dark.png and b/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--dark.png differ
diff --git a/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--light.png b/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--light.png
index 8f982cacab5c2..40ff9d12b2ba2 100644
Binary files a/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--light.png and b/frontend/__snapshots__/components-errors-error-display--with-cymbal-errors--light.png differ
diff --git a/frontend/__snapshots__/components-hogfetti--hogfetti--dark.png b/frontend/__snapshots__/components-hogfetti--hogfetti--dark.png
index 1e92a6a972426..cc6a66966c712 100644
Binary files a/frontend/__snapshots__/components-hogfetti--hogfetti--dark.png and b/frontend/__snapshots__/components-hogfetti--hogfetti--dark.png differ
diff --git a/frontend/__snapshots__/components-hogfetti--hogfetti--light.png b/frontend/__snapshots__/components-hogfetti--hogfetti--light.png
index b507aeb43422a..038547ad16f06 100644
Binary files a/frontend/__snapshots__/components-hogfetti--hogfetti--light.png and b/frontend/__snapshots__/components-hogfetti--hogfetti--light.png differ
diff --git a/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--dark.png b/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--dark.png
index e356532ca0e6d..25a32339e8edb 100644
Binary files a/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--dark.png and b/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--dark.png differ
diff --git a/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--light.png b/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--light.png
index ac6439a3b0f62..513b3ed148bb7 100644
Binary files a/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--light.png and b/frontend/__snapshots__/components-hogqleditor--hog-ql-editor--light.png differ
diff --git a/frontend/__snapshots__/components-hogqleditor--no-value--dark.png b/frontend/__snapshots__/components-hogqleditor--no-value--dark.png
index 4d295c7431ebf..5ceff04a1d206 100644
Binary files a/frontend/__snapshots__/components-hogqleditor--no-value--dark.png and b/frontend/__snapshots__/components-hogqleditor--no-value--dark.png differ
diff --git a/frontend/__snapshots__/components-hogqleditor--no-value--light.png b/frontend/__snapshots__/components-hogqleditor--no-value--light.png
index 401a4e98e08ce..2038e29ae4087 100644
Binary files a/frontend/__snapshots__/components-hogqleditor--no-value--light.png and b/frontend/__snapshots__/components-hogqleditor--no-value--light.png differ
diff --git a/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--dark.png b/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--dark.png
index 4d295c7431ebf..5ceff04a1d206 100644
Binary files a/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--dark.png and b/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--dark.png differ
diff --git a/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--light.png b/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--light.png
index 401a4e98e08ce..2038e29ae4087 100644
Binary files a/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--light.png and b/frontend/__snapshots__/components-hogqleditor--no-value-person-properties-disabled--light.png differ
diff --git a/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--dark.png b/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--dark.png
index 21c8c0c700b98..d5207c220209d 100644
Binary files a/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--dark.png and b/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--dark.png differ
diff --git a/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--light.png b/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--light.png
index 447fa7b473966..28cfc2ba09456 100644
Binary files a/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--light.png and b/frontend/__snapshots__/components-html-elements-display--small-with-uniqueness-check--light.png differ
diff --git a/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--dark.png b/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--dark.png
index 21c8c0c700b98..d5207c220209d 100644
Binary files a/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--dark.png and b/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--dark.png differ
diff --git a/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--light.png b/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--light.png
index 447fa7b473966..28cfc2ba09456 100644
Binary files a/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--light.png and b/frontend/__snapshots__/components-html-elements-display--with-uniqueness-check--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--dark.png
index e9fe7de459ce9..2ad22e1251aa4 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--light.png
index b31b13bf96316..61c142b66d388 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--all-slow--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--default--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--default--dark.png
index 557a24ad829de..225413d72709d 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--default--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--default--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--default--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--default--light.png
index 18eeafe53a294..0dddcd3fa4040 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--default--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--default--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--dark.png
index 557a24ad829de..225413d72709d 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--light.png
index 18eeafe53a294..0dddcd3fa4040 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--expanded--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--dark.png
index 9c3fb1e344f74..acec91d9d5770 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--light.png
index e41e7dec7df53..e35cf20e724cf 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-dom-interactive--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--dark.png
index 2517ac22b8fc9..fac9168f5b922 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--light.png
index 4fce8a837f7a9..9786d21e2280d 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-fcp--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--dark.png
index d9b70116e57b6..772ca47300a43 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--light.png
index 88ad89c98e8d9..33839ce93e4d1 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--really-slow-load-event--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--dark.png
index 0dac5dff8a31f..876339c60c48f 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--light.png
index b6af1c8e969b6..09f1c1bbb0700 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-dom-interactive--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--dark.png
index 7ca69b7425a30..85b075a0f290d 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--light.png
index 4a9a95e7c36d7..4716324e22c09 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-fcp--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--dark.png
index 657492c654a5d..f61d8a1aa9217 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--light.png
index 7be9fca3cf6be..4125a9641deab 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--slow-load-event--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--dark.png
index ab975529f0e67..197dba2e766b2 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--light.png
index a4a1c5246525b..e3f9727ae5b77 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-fast--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--dark.png
index 0cc51fee095f6..fe75b85b1853b 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--light.png
index 312e4ac544ef9..53680276c8d44 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-medium--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--dark.png
index 13921a926aa45..56ec6eb839a55 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--light.png
index bca3d330610fc..c415408379d3b 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-all-slow--light.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--dark.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--dark.png
index 488140bfb1571..ae176c67d2aa2 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--dark.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--dark.png differ
diff --git a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--light.png b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--light.png
index 5dea38e2b1c7f..7e9e414273a44 100644
Binary files a/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--light.png and b/frontend/__snapshots__/components-networkrequest-navigationitem--web-vitals-loading--light.png differ
diff --git a/frontend/__snapshots__/components-playerinspector--default--dark.png b/frontend/__snapshots__/components-playerinspector--default--dark.png
index ad65001574fd4..87c483c27613a 100644
Binary files a/frontend/__snapshots__/components-playerinspector--default--dark.png and b/frontend/__snapshots__/components-playerinspector--default--dark.png differ
diff --git a/frontend/__snapshots__/components-playerinspector--default--light.png b/frontend/__snapshots__/components-playerinspector--default--light.png
index a2c075a113bd2..04f141310bd43 100644
Binary files a/frontend/__snapshots__/components-playerinspector--default--light.png and b/frontend/__snapshots__/components-playerinspector--default--light.png differ
diff --git a/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--dark.png b/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--dark.png
index cb009d55395dd..b529d9ec4168f 100644
Binary files a/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--dark.png and b/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--dark.png differ
diff --git a/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--light.png b/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--light.png
index 4c8ac367ea329..5598463df851b 100644
Binary files a/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--light.png and b/frontend/__snapshots__/components-properties-table--dollar-properties-on-person-hidden--light.png differ
diff --git a/frontend/__snapshots__/components-subscriptions--subscription-no-integrations--dark.png b/frontend/__snapshots__/components-subscriptions--subscription-no-integrations--dark.png
index 865fb0aa346b8..d98df60929d78 100644
Binary files a/frontend/__snapshots__/components-subscriptions--subscription-no-integrations--dark.png and b/frontend/__snapshots__/components-subscriptions--subscription-no-integrations--dark.png differ
diff --git a/frontend/__snapshots__/components-subscriptions--subscriptions-new--dark.png b/frontend/__snapshots__/components-subscriptions--subscriptions-new--dark.png
index 7aa30537bd437..d98df60929d78 100644
Binary files a/frontend/__snapshots__/components-subscriptions--subscriptions-new--dark.png and b/frontend/__snapshots__/components-subscriptions--subscriptions-new--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-code-snippet--with-wrapping-and-action--dark.png b/frontend/__snapshots__/lemon-ui-code-snippet--with-wrapping-and-action--dark.png
index 5660310dc865b..a2f322aaa8290 100644
Binary files a/frontend/__snapshots__/lemon-ui-code-snippet--with-wrapping-and-action--dark.png and b/frontend/__snapshots__/lemon-ui-code-snippet--with-wrapping-and-action--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-code-snippet--without-wrapping-with-action--dark.png b/frontend/__snapshots__/lemon-ui-code-snippet--without-wrapping-with-action--dark.png
index ea1710a944a8c..dcbb67b8d51b8 100644
Binary files a/frontend/__snapshots__/lemon-ui-code-snippet--without-wrapping-with-action--dark.png and b/frontend/__snapshots__/lemon-ui-code-snippet--without-wrapping-with-action--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-icons--shelf-j--light.png b/frontend/__snapshots__/lemon-ui-icons--shelf-j--light.png
index 04be0b77f544f..0e611033cda35 100644
Binary files a/frontend/__snapshots__/lemon-ui-icons--shelf-j--light.png and b/frontend/__snapshots__/lemon-ui-icons--shelf-j--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--multiple-digits--dark.png b/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--multiple-digits--dark.png
index 5a32be0344360..5de7383368eaf 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--multiple-digits--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--multiple-digits--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--show-zero--dark.png b/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--show-zero--dark.png
index 7006b55bebdd8..31c5a789465d0 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--show-zero--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--show-zero--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--standard--dark.png b/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--standard--dark.png
index 932b20cf6fa45..5b88c9eed7a88 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--standard--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-badge-lemon-badge-number--standard--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--closable--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--closable--dark.png
index 7840ca42cb736..e648e224765de 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--closable--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--closable--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--closable--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--closable--light.png
index d9ce96b32ed2f..efeed5e57f854 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--closable--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--closable--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--dark.png
index 1bf56394b7007..f18ad86246022 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--light.png
index d6363800a423c..94b6fc1daf114 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--dismissable--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--error--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--error--dark.png
index f931361312c1b..9ec84b1eb45ab 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--error--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--error--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--error--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--error--light.png
index f2a38ac128937..101ee45ce5f9a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--error--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--error--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--info--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--info--dark.png
index 2802006b65749..25570af1797d9 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--info--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--info--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--info--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--info--light.png
index 43c3baeb614e9..cfb0d093cf59c 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--info--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--info--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--dark.png
index dda64fb366625..28206ca98bf0a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--light.png
index 3d77a66ab40d3..775d33eca3959 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--dark.png
index 77d8942fd56dd..efa19dd9a31a9 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--light.png
index 4607d11318285..3f5f28e4c2f13 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--narrow-with-buttons--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--success--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--success--dark.png
index 3548a56188f16..6717e6e657649 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--success--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--success--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--success--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--success--light.png
index bec5747abc9c9..3876283e32fc3 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--success--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--success--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--warning--dark.png b/frontend/__snapshots__/lemon-ui-lemon-banner--warning--dark.png
index c0885ef680b4d..74d4a6713b414 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--warning--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--warning--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-banner--warning--light.png b/frontend/__snapshots__/lemon-ui-lemon-banner--warning--light.png
index 5051d6c6fba30..75d37b5a5d707 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-banner--warning--light.png and b/frontend/__snapshots__/lemon-ui-lemon-banner--warning--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--active--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--active--dark.png
index cdca348aa0cbe..bae9289646168 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--active--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--active--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--as-links--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--as-links--dark.png
index 63b7bfd9b1293..6fedd1afb34a6 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--as-links--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--as-links--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--as-links--light.png b/frontend/__snapshots__/lemon-ui-lemon-button--as-links--light.png
index 550cee152c102..60e53b09ed81b 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--as-links--light.png and b/frontend/__snapshots__/lemon-ui-lemon-button--as-links--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--dark.png
index 61a065c8c35b8..e42314aee217d 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--light.png b/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--light.png
index 4ca1808ad1865..0e7f1e20c0ad5 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--light.png and b/frontend/__snapshots__/lemon-ui-lemon-button--disabled-with-reason--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--full-width--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--full-width--dark.png
index 4de1960f0fb63..749b74e5404cd 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--full-width--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--full-width--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--menu-buttons--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--menu-buttons--dark.png
index 9a6adc09abdfc..3fcc85acaeb11 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--menu-buttons--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--menu-buttons--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--pseudo-states--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--pseudo-states--dark.png
index 7a79087a8d109..0494072b9e653 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--pseudo-states--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--pseudo-states--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--sizes--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--sizes--dark.png
index 7be31ba710f2c..e92436727bc80 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--sizes--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--sizes--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--text-only--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--text-only--dark.png
index 3ea250d025cec..689e130598d90 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--text-only--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--text-only--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--text-only--light.png b/frontend/__snapshots__/lemon-ui-lemon-button--text-only--light.png
index db7cf5217fe07..3abe51f3e6627 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--text-only--light.png and b/frontend/__snapshots__/lemon-ui-lemon-button--text-only--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-button--types-and-statuses--dark.png b/frontend/__snapshots__/lemon-ui-lemon-button--types-and-statuses--dark.png
index a1ae61bc8afd5..54a16eba7b82d 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-button--types-and-statuses--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-button--types-and-statuses--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--dark.png
index 692203c75b49e..2796435eb68ff 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--light.png
index 63975d42c24c9..958d095dc7b38 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--custom-styles--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--dark.png
index af5eb35b4a393..320f0dfb39709 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--light.png
index b7c759035f7be..1ec1d92d13bc5 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--default--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--dark.png
index c70073759a9c3..e2a7d303c9bf3 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--light.png
index fd30577a0f79f..c67e7eff5f2d6 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--friday-first--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--dark.png
index 97b6b6671f4b7..62005fd240d46 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--light.png
index 46de463f355a3..deb1a4130559e 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--hour--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--dark.png
index 6e53b5cd15413..ccb0203a5d2c3 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--light.png
index 6d29186846f99..c7001a1113b24 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--minute--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--dark.png
index f86bca1b53ab8..0d37818b855a9 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--light.png
index 3015065991f8b..32569ecc291ad 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--multiple-months--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--dark.png
index d3cdc976bcd4d..0ca2d8c95c36b 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--light.png
index 989bb7dc4e1f3..1382bcae5ed6b 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--saturday-first--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--dark.png
index af5eb35b4a393..320f0dfb39709 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--light.png
index b7c759035f7be..1ec1d92d13bc5 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--sunday-first--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--dark.png
index f1cc69206e84b..d6279a75e1b90 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--light.png
index 65cfd36b3081a..39a2c68e2cd5e 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--thursday-first--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--dark.png
index 13aa1b9a431a2..bcc3113d51f69 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--light.png
index a575e4ef6b228..161c7033dbea2 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar--wednesday-first--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--dark.png
index fc30b65924d01..841266fbca5bf 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--light.png
index 3737e331119c9..514ed70766db7 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--default--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--dark.png
index c07fa500efba1..022a1933f0729 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--light.png
index dd6fa19630b65..8081ad0512c0a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--hour--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--dark.png
index 09f57c49a2ddd..35a1560f55720 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--light.png
index 7357eb0db768b..be88a38b80777 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--minute--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--dark.png
index d692fb5269ff0..0728b9da4ad59 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--light.png
index 655ce9d87c47c..eda77f53e84d4 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--past--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--dark.png
index 62707fb6e89a2..bf29f763f7162 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--light.png
index 8248c8be132db..331ac9df5287a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--upcoming--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--dark.png
index f595113e318ad..57fa737a559ed 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--light.png
index f8fbf21738bde..91bf217461bb6 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--light.png and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle-and-multiple-months--dark.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle-and-multiple-months--dark.png
new file mode 100644
index 0000000000000..5d0408386245a
Binary files /dev/null and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle-and-multiple-months--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle-and-multiple-months--light.png b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle-and-multiple-months--light.png
new file mode 100644
index 0000000000000..6386c0c6b6f99
Binary files /dev/null and b/frontend/__snapshots__/lemon-ui-lemon-calendar-lemon-calendar-select--with-time-toggle-and-multiple-months--light.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-dialog--customised--dark.png b/frontend/__snapshots__/lemon-ui-lemon-dialog--customised--dark.png
index b898f2112d37f..299dfb968ba0f 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-dialog--customised--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-dialog--customised--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-modal--lemon-modal--dark.png b/frontend/__snapshots__/lemon-ui-lemon-modal--lemon-modal--dark.png
index d523c3aad154a..e6995794582f3 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-modal--lemon-modal--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-modal--lemon-modal--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-modal--without-content--dark.png b/frontend/__snapshots__/lemon-ui-lemon-modal--without-content--dark.png
index d523c3aad154a..e6995794582f3 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-modal--without-content--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-modal--without-content--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-segmented-button--default--dark.png b/frontend/__snapshots__/lemon-ui-lemon-segmented-button--default--dark.png
index d55e8cbeb48c7..11267310b2e8a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-segmented-button--default--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-segmented-button--default--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-segmented-button--full-width--dark.png b/frontend/__snapshots__/lemon-ui-lemon-segmented-button--full-width--dark.png
index d55e8cbeb48c7..11267310b2e8a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-segmented-button--full-width--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-segmented-button--full-width--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-segmented-button--small--dark.png b/frontend/__snapshots__/lemon-ui-lemon-segmented-button--small--dark.png
index d8e409a48cfaa..cec8821312150 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-segmented-button--small--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-segmented-button--small--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-segmented-select--default--dark.png b/frontend/__snapshots__/lemon-ui-lemon-segmented-select--default--dark.png
index 9ca8c01118d7d..11267310b2e8a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-segmented-select--default--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-segmented-select--default--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-segmented-select--full-width--dark.png b/frontend/__snapshots__/lemon-ui-lemon-segmented-select--full-width--dark.png
index 9ca8c01118d7d..11267310b2e8a 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-segmented-select--full-width--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-segmented-select--full-width--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-segmented-select--small--dark.png b/frontend/__snapshots__/lemon-ui-lemon-segmented-select--small--dark.png
index a77d3f7434fb8..cec8821312150 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-segmented-select--small--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-segmented-select--small--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-toast--toast-types--dark.png b/frontend/__snapshots__/lemon-ui-lemon-toast--toast-types--dark.png
index 6e5c72e870205..33f03744d7ba5 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-toast--toast-types--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-toast--toast-types--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-toast--with-button--dark.png b/frontend/__snapshots__/lemon-ui-lemon-toast--with-button--dark.png
index 8d7cf020283cb..707b72bec5e34 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-toast--with-button--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-toast--with-button--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-lemon-toast--with-progress--dark.png b/frontend/__snapshots__/lemon-ui-lemon-toast--with-progress--dark.png
index 022e40aa17ce0..c4bac6bfde234 100644
Binary files a/frontend/__snapshots__/lemon-ui-lemon-toast--with-progress--dark.png and b/frontend/__snapshots__/lemon-ui-lemon-toast--with-progress--dark.png differ
diff --git a/frontend/__snapshots__/lemon-ui-spinner--in-buttons--dark.png b/frontend/__snapshots__/lemon-ui-spinner--in-buttons--dark.png
index 228f14acdef0c..2b66836306961 100644
Binary files a/frontend/__snapshots__/lemon-ui-spinner--in-buttons--dark.png and b/frontend/__snapshots__/lemon-ui-spinner--in-buttons--dark.png differ
diff --git a/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--dark.png b/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--dark.png
index 9e94e50e11369..f5ed8a89ac925 100644
Binary files a/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--dark.png and b/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--dark.png differ
diff --git a/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--light.png b/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--light.png
index afcf5cd9c035f..b2493c895f8bd 100644
Binary files a/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--light.png and b/frontend/__snapshots__/posthog-3000-navigation--navigation-3000--light.png differ
diff --git a/frontend/__snapshots__/posthog-3000-navigation--navigation-base--dark.png b/frontend/__snapshots__/posthog-3000-navigation--navigation-base--dark.png
index 70a50e26d5e7b..d807d8d4ef08d 100644
Binary files a/frontend/__snapshots__/posthog-3000-navigation--navigation-base--dark.png and b/frontend/__snapshots__/posthog-3000-navigation--navigation-base--dark.png differ
diff --git a/frontend/__snapshots__/posthog-3000-sidebar--dashboards--dark.png b/frontend/__snapshots__/posthog-3000-sidebar--dashboards--dark.png
index d66b1f11c1a6b..758c48c0daa81 100644
Binary files a/frontend/__snapshots__/posthog-3000-sidebar--dashboards--dark.png and b/frontend/__snapshots__/posthog-3000-sidebar--dashboards--dark.png differ
diff --git a/frontend/__snapshots__/posthog-3000-sidebar--dashboards--light.png b/frontend/__snapshots__/posthog-3000-sidebar--dashboards--light.png
index eef82575bea8b..c05ba32634144 100644
Binary files a/frontend/__snapshots__/posthog-3000-sidebar--dashboards--light.png and b/frontend/__snapshots__/posthog-3000-sidebar--dashboards--light.png differ
diff --git a/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--dark.png b/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--dark.png
index 687b3e5258355..8c556eeb82689 100644
Binary files a/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--dark.png and b/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--dark.png differ
diff --git a/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--light.png b/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--light.png
index 01823e88fef50..6600ad600011f 100644
Binary files a/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--light.png and b/frontend/__snapshots__/posthog-3000-sidebar--feature-flags--light.png differ
diff --git a/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png b/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png
index 7c84465a4fd8f..e05ec0ee257d3 100644
Binary files a/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png and b/frontend/__snapshots__/replay-player-failure--recent-recordings-404--dark.png differ
diff --git a/frontend/__snapshots__/replay-player-failure--recent-recordings-404--light.png b/frontend/__snapshots__/replay-player-failure--recent-recordings-404--light.png
index 8008f3eb43eca..4d5f9882073b5 100644
Binary files a/frontend/__snapshots__/replay-player-failure--recent-recordings-404--light.png and b/frontend/__snapshots__/replay-player-failure--recent-recordings-404--light.png differ
diff --git a/frontend/__snapshots__/replay-player-success--recent-recordings--dark.png b/frontend/__snapshots__/replay-player-success--recent-recordings--dark.png
index c02be573f0f34..2392b90f55117 100644
Binary files a/frontend/__snapshots__/replay-player-success--recent-recordings--dark.png and b/frontend/__snapshots__/replay-player-success--recent-recordings--dark.png differ
diff --git a/frontend/__snapshots__/replay-player-success--recent-recordings--light.png b/frontend/__snapshots__/replay-player-success--recent-recordings--light.png
index ace7d3debd600..130aa9a287ffd 100644
Binary files a/frontend/__snapshots__/replay-player-success--recent-recordings--light.png and b/frontend/__snapshots__/replay-player-success--recent-recordings--light.png differ
diff --git a/frontend/__snapshots__/replay-player-success--second-recording-in-list--dark.png b/frontend/__snapshots__/replay-player-success--second-recording-in-list--dark.png
index 03870e07340f4..93ad7064fd68b 100644
Binary files a/frontend/__snapshots__/replay-player-success--second-recording-in-list--dark.png and b/frontend/__snapshots__/replay-player-success--second-recording-in-list--dark.png differ
diff --git a/frontend/__snapshots__/replay-player-success--second-recording-in-list--light.png b/frontend/__snapshots__/replay-player-success--second-recording-in-list--light.png
index 576caf4f434a2..537566ccb05ab 100644
Binary files a/frontend/__snapshots__/replay-player-success--second-recording-in-list--light.png and b/frontend/__snapshots__/replay-player-success--second-recording-in-list--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png b/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png
index 5db2152719be9..df722bd0f2d26 100644
Binary files a/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png and b/frontend/__snapshots__/scenes-app-errortracking--group-page--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png b/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png
index 0aad92c68ce5f..477239b6b7587 100644
Binary files a/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png and b/frontend/__snapshots__/scenes-app-errortracking--group-page--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-errortracking--list-page--dark.png b/frontend/__snapshots__/scenes-app-errortracking--list-page--dark.png
index a5621ecc99e11..7fbea863d2331 100644
Binary files a/frontend/__snapshots__/scenes-app-errortracking--list-page--dark.png and b/frontend/__snapshots__/scenes-app-errortracking--list-page--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-errortracking--list-page--light.png b/frontend/__snapshots__/scenes-app-errortracking--list-page--light.png
index 9bbbf1b37f239..fa92d131cd17f 100644
Binary files a/frontend/__snapshots__/scenes-app-errortracking--list-page--light.png and b/frontend/__snapshots__/scenes-app-errortracking--list-page--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-experiments--complete-funnel-experiment--dark.png b/frontend/__snapshots__/scenes-app-experiments--complete-funnel-experiment--dark.png
index b2f928130be50..2449e1ce566bd 100644
Binary files a/frontend/__snapshots__/scenes-app-experiments--complete-funnel-experiment--dark.png and b/frontend/__snapshots__/scenes-app-experiments--complete-funnel-experiment--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png b/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png
index 4978c38f5e986..b969c8e32854a 100644
Binary files a/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png and b/frontend/__snapshots__/scenes-app-experiments--experiments-list--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment--dark.png b/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment--dark.png
index d5637e0b03a16..a6d3889b23a43 100644
Binary files a/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment--dark.png and b/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment-many-variants--dark.png b/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment-many-variants--dark.png
index c50f33e6d898c..daf12837bf697 100644
Binary files a/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment-many-variants--dark.png and b/frontend/__snapshots__/scenes-app-experiments--running-trend-experiment-many-variants--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--dark.png b/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--dark.png
index 08312752ac112..835b68b2ea10d 100644
Binary files a/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--dark.png and b/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--light.png b/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--light.png
index 8a55f274bf3f3..64f704c6a75bc 100644
Binary files a/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--light.png and b/frontend/__snapshots__/scenes-app-feature-flags--new-feature-flag--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-no-pages-available--dark.png b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-no-pages-available--dark.png
index f8dde32675261..388f05bff2379 100644
Binary files a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-no-pages-available--dark.png and b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-no-pages-available--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-page-selected--dark.png b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-page-selected--dark.png
index 79b726f68b1cd..b8a56a896b3d1 100644
Binary files a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-page-selected--dark.png and b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-page-selected--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--dark.png b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--dark.png
index 8821684eea618..1b0608ca30a28 100644
Binary files a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--dark.png and b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--light.png b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--light.png
index b6ce8b8910607..c2f535216405b 100644
Binary files a/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--light.png and b/frontend/__snapshots__/scenes-app-heatmaps--heatmaps-browser-with-unauthorized-page-selected--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark--webkit.png b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark--webkit.png
index 587abfccb4aa5..a1c8d5a8d59af 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark--webkit.png and b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark--webkit.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark.png b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark.png
index ac19e318a3f94..695536b9bcac8 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark.png and b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light--webkit.png b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light--webkit.png
index 8ad5ae4d07ef6..73e5f193806a7 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light--webkit.png and b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light--webkit.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light.png b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light.png
index 64bcb81eb0d5d..6512dbd87e1db 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light.png and b/frontend/__snapshots__/scenes-app-insights--funnel-historical-trends-edit--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--dark.png b/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--dark.png
index 64260538a2c7b..ee27b11bed568 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--dark.png and b/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--light.png b/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--light.png
index 25ab8cd06fd02..00916265cd38b 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--light.png and b/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-breakdown-edit--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-edit--dark.png b/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-edit--dark.png
index d4389462f0b58..248d1f34b318a 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-edit--dark.png and b/frontend/__snapshots__/scenes-app-insights--funnel-top-to-bottom-edit--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark--webkit.png b/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark--webkit.png
index 6b73a796de5fe..8193f6628caff 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark--webkit.png and b/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark--webkit.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark.png b/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark.png
index 9b5ea77184db9..0cd89979f05a3 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark.png and b/frontend/__snapshots__/scenes-app-insights--trends-line-edit--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights--trends-line-multi--dark--webkit.png b/frontend/__snapshots__/scenes-app-insights--trends-line-multi--dark--webkit.png
index 3551a39f9d5b0..76fa0b9d70502 100644
Binary files a/frontend/__snapshots__/scenes-app-insights--trends-line-multi--dark--webkit.png and b/frontend/__snapshots__/scenes-app-insights--trends-line-multi--dark--webkit.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--dark.png b/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--dark.png
index 53a38ebe97627..7f17c93cf8695 100644
Binary files a/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--dark.png and b/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--light.png b/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--light.png
index b6956d05b33b5..149a6d0c31e64 100644
Binary files a/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--light.png and b/frontend/__snapshots__/scenes-app-insights-error-empty-states--long-loading--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--dark.png b/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--dark.png
index ab8433877a9e5..64cc334785eda 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--dark.png and b/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--light.png b/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--light.png
index e5bac9eeee8f1..756eb74f6156b 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--light.png and b/frontend/__snapshots__/scenes-app-max-ai--empty-thread-loading--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--dark.png b/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--dark.png
index db43716077ebe..27244118ba4a0 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--dark.png and b/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--light.png b/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--light.png
index cc409784b1c45..6f13b687b5156 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--light.png and b/frontend/__snapshots__/scenes-app-max-ai--generation-failure-thread--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--thread--dark.png b/frontend/__snapshots__/scenes-app-max-ai--thread--dark.png
index 6f6b491670b99..78d4b44700226 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--thread--dark.png and b/frontend/__snapshots__/scenes-app-max-ai--thread--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--thread--light.png b/frontend/__snapshots__/scenes-app-max-ai--thread--light.png
index c456bd0c5fde0..d300a75be4dc6 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--thread--light.png and b/frontend/__snapshots__/scenes-app-max-ai--thread--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--dark.png b/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--dark.png
index 803390e1b9822..f7e1627246573 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--dark.png and b/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--light.png b/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--light.png
index b785e83e2206f..1bcb94198a8b6 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--light.png and b/frontend/__snapshots__/scenes-app-max-ai--thread-with-rate-limit--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--welcome--dark.png b/frontend/__snapshots__/scenes-app-max-ai--welcome--dark.png
index c844325595b28..3fdfad1c20908 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--welcome--dark.png and b/frontend/__snapshots__/scenes-app-max-ai--welcome--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--dark.png b/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--dark.png
index be67ab75d125b..eee71a3783a06 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--dark.png and b/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--light.png b/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--light.png
index cf026b65c4994..358c01f1ccdae 100644
Binary files a/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--light.png and b/frontend/__snapshots__/scenes-app-max-ai--welcome-loading-suggestions--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--dark.png b/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--dark.png
index 11ea424b098d0..160760e0f576d 100644
Binary files a/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--dark.png and b/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--light.png b/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--light.png
index 20411145690cb..92db4ba9ff45e 100644
Binary files a/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--light.png and b/frontend/__snapshots__/scenes-app-notebooks--notebooks-list--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--dark.png b/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--dark.png
index d606d44e5e440..1c682a169746a 100644
Binary files a/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--dark.png and b/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--light.png b/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--light.png
index 19fd725a92aca..4a8389daacd3a 100644
Binary files a/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--light.png and b/frontend/__snapshots__/scenes-app-notebooks--recordings-playlist--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page--dark.png b/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page--dark.png
index 536e789b3e2bf..2f712d0266fe1 100644
Binary files a/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page--dark.png and b/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page-without-pipelines--dark.png b/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page-without-pipelines--dark.png
index e7ee037d2db5a..6df95747f77ef 100644
Binary files a/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page-without-pipelines--dark.png and b/frontend/__snapshots__/scenes-app-pipeline--pipeline-destinations-page-without-pipelines--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-big-query--dark.png b/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-big-query--dark.png
index 4093411b824a6..6f93fdda8e5f4 100644
Binary files a/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-big-query--dark.png and b/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-big-query--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--dark.png b/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--dark.png
index b8b549ad31a31..d39232bc20b73 100644
Binary files a/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--dark.png and b/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--light.png b/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--light.png
index 4afdf7cf81cfb..a128cf65fde2e 100644
Binary files a/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--light.png and b/frontend/__snapshots__/scenes-app-pipeline--pipeline-node-new-hog-function--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-pipeline--pipeline-nodes-management-page--dark.png b/frontend/__snapshots__/scenes-app-pipeline--pipeline-nodes-management-page--dark.png
index cc34a11485191..3749d39986466 100644
Binary files a/frontend/__snapshots__/scenes-app-pipeline--pipeline-nodes-management-page--dark.png and b/frontend/__snapshots__/scenes-app-pipeline--pipeline-nodes-management-page--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--dark.png b/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--dark.png
index 820998e556ba5..aeb5c204bdf51 100644
Binary files a/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--dark.png and b/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--light.png b/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--light.png
index e7ec3a315684b..720fc8ce9e6c3 100644
Binary files a/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--light.png and b/frontend/__snapshots__/scenes-app-sessionattributionexplorer--session-attribution-explorer--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-activation--dark.png b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-activation--dark.png
index fc93723027d33..10d3e242df26a 100644
Binary files a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-activation--dark.png and b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-activation--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-docs--dark.png b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-docs--dark.png
index 98c143d93d5b7..180284766d7da 100644
Binary files a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-docs--dark.png and b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-docs--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-notebooks--dark.png b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-notebooks--dark.png
index 169cab94e78cc..a55904927d4df 100644
Binary files a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-notebooks--dark.png and b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-notebooks--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--dark.png b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--dark.png
index 923fe9d53a9c8..51fe54193e7dd 100644
Binary files a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--dark.png and b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--light.png b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--light.png
index 8ac25dbcb685c..a5428e6294540 100644
Binary files a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--light.png and b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-settings--light.png differ
diff --git a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-no-email--dark.png b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-no-email--dark.png
index 907f97aa1f5b2..03fe4c6ea65ee 100644
Binary files a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-no-email--dark.png and b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-no-email--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-with-email--dark.png b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-with-email--dark.png
index 918b0b0d8cf6e..0a32462d3ed9e 100644
Binary files a/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-with-email--dark.png and b/frontend/__snapshots__/scenes-app-sidepanels--side-panel-support-with-email--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-surveys--new-survey-targeting-section--dark.png b/frontend/__snapshots__/scenes-app-surveys--new-survey-targeting-section--dark.png
index ae7822ea5b860..16719722cec24 100644
Binary files a/frontend/__snapshots__/scenes-app-surveys--new-survey-targeting-section--dark.png and b/frontend/__snapshots__/scenes-app-surveys--new-survey-targeting-section--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-surveys--surveys-list--dark.png b/frontend/__snapshots__/scenes-app-surveys--surveys-list--dark.png
index 70d439fbf26a9..4ca173794e1a0 100644
Binary files a/frontend/__snapshots__/scenes-app-surveys--surveys-list--dark.png and b/frontend/__snapshots__/scenes-app-surveys--surveys-list--dark.png differ
diff --git a/frontend/__snapshots__/scenes-app-surveys--surveys-list--light.png b/frontend/__snapshots__/scenes-app-surveys--surveys-list--light.png
index 0ae472abeef7e..7979111b8b036 100644
Binary files a/frontend/__snapshots__/scenes-app-surveys--surveys-list--light.png and b/frontend/__snapshots__/scenes-app-surveys--surveys-list--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal--dark.png b/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal--dark.png
index 0cd41b32b0322..631019cafacdd 100644
Binary files a/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal--dark.png and b/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal-data-pipelines--dark.png b/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal-data-pipelines--dark.png
index 000cf871d37cd..74aee901a398c 100644
Binary files a/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal-data-pipelines--dark.png and b/frontend/__snapshots__/scenes-other-billing--billing-unsubscribe-modal-data-pipelines--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-billing--billing-with-credit-cta--dark.png b/frontend/__snapshots__/scenes-other-billing--billing-with-credit-cta--dark.png
index 505db4406be40..3287c8e015277 100644
Binary files a/frontend/__snapshots__/scenes-other-billing--billing-with-credit-cta--dark.png and b/frontend/__snapshots__/scenes-other-billing--billing-with-credit-cta--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--dark.png b/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--dark.png
index b2062e06f4a10..c5067b4f13221 100644
Binary files a/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--dark.png and b/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--light.png b/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--light.png
index fe5652295d73c..06ddf95b64e5f 100644
Binary files a/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--light.png and b/frontend/__snapshots__/scenes-other-billing-product--billing-product-temporarily-free--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-login--second-factor--dark.png b/frontend/__snapshots__/scenes-other-login--second-factor--dark.png
index 775f77110f211..8dc59e1e8c104 100644
Binary files a/frontend/__snapshots__/scenes-other-login--second-factor--dark.png and b/frontend/__snapshots__/scenes-other-login--second-factor--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-login--second-factor--light.png b/frontend/__snapshots__/scenes-other-login--second-factor--light.png
index 54ed53c9fdb7f..f6db8d0a35316 100644
Binary files a/frontend/__snapshots__/scenes-other-login--second-factor--light.png and b/frontend/__snapshots__/scenes-other-login--second-factor--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-login--sso-error--dark.png b/frontend/__snapshots__/scenes-other-login--sso-error--dark.png
index fbc54832bece1..172967f784968 100644
Binary files a/frontend/__snapshots__/scenes-other-login--sso-error--dark.png and b/frontend/__snapshots__/scenes-other-login--sso-error--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-onboarding--onboarding-billing--light.png b/frontend/__snapshots__/scenes-other-onboarding--onboarding-billing--light.png
index 93338096ad6c9..95511e628778d 100644
Binary files a/frontend/__snapshots__/scenes-other-onboarding--onboarding-billing--light.png and b/frontend/__snapshots__/scenes-other-onboarding--onboarding-billing--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--dark.png b/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--dark.png
index e23d1c60a85ce..535804d77de4e 100644
Binary files a/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--dark.png and b/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--light.png b/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--light.png
index 774cb7beb60c7..9494cdccd7b4a 100644
Binary files a/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--light.png and b/frontend/__snapshots__/scenes-other-onboarding--onboarding-sd-ks--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--dark.png b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--dark.png
index 2108bf08e480f..9533045495757 100644
Binary files a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--dark.png and b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--light.png b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--light.png
index e797cc6467cfc..e6876dcaf9403 100644
Binary files a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--light.png and b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-admin--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--dark.png b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--dark.png
index 644dc1a22f0eb..c299d9caf9d5d 100644
Binary files a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--dark.png and b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--light.png b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--light.png
index 750ff00450e15..3a632563f3dd4 100644
Binary files a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--light.png and b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-member--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--dark.png b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--dark.png
index 2108bf08e480f..9533045495757 100644
Binary files a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--dark.png and b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--light.png b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--light.png
index e797cc6467cfc..e6876dcaf9403 100644
Binary files a/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--light.png and b/frontend/__snapshots__/scenes-other-org-member-invites--current-user-is-owner--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-password-reset--initial--dark.png b/frontend/__snapshots__/scenes-other-password-reset--initial--dark.png
index 0abf0df2c194b..901a5be7244e5 100644
Binary files a/frontend/__snapshots__/scenes-other-password-reset--initial--dark.png and b/frontend/__snapshots__/scenes-other-password-reset--initial--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-organization--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-organization--dark.png
index c063bc66591f6..32d397abf284c 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-organization--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-organization--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-organization--light.png b/frontend/__snapshots__/scenes-other-settings--settings-organization--light.png
index 53d8c00a4492e..7ae06bd540053 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-organization--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-organization--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-project--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-project--dark.png
index 23e20084b753d..bcef1677c71eb 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-project--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-project--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-project--light.png b/frontend/__snapshots__/scenes-other-settings--settings-project--light.png
index f7b7f6ebd06e6..bf25bd234a23a 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-project--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-project--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--dark.png
index eb8542bfdcfcc..d2302cf2491a4 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--light.png b/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--light.png
index 999b15cfdd917..ccab613598663 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-project-with-replay-features--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--dark.png
index 23e20084b753d..bcef1677c71eb 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--light.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--light.png
index f7b7f6ebd06e6..bf25bd234a23a 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-all-options--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--dark.png
index 23e20084b753d..bcef1677c71eb 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--light.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--light.png
index f7b7f6ebd06e6..bf25bd234a23a 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-password-only--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--dark.png
index 23e20084b753d..bcef1677c71eb 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--light.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--light.png
index f7b7f6ebd06e6..bf25bd234a23a 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-github--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--dark.png
index 23e20084b753d..bcef1677c71eb 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--light.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--light.png
index f7b7f6ebd06e6..bf25bd234a23a 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-google--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--dark.png
index 23e20084b753d..bcef1677c71eb 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--light.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--light.png
index f7b7f6ebd06e6..bf25bd234a23a 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-enforced-saml--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--dark.png
index 23e20084b753d..bcef1677c71eb 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--light.png b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--light.png
index f7b7f6ebd06e6..bf25bd234a23a 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-session-timeout-sso-only--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-user--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-user--dark.png
index b76714d7b9006..f0f85a24787f5 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-user--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-user--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-user--light.png b/frontend/__snapshots__/scenes-other-settings--settings-user--light.png
index 5d1b0d30a4d1c..4cd020a3df66e 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-user--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-user--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--dark.png b/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--dark.png
index 7da712a894a4c..d16b8c42a3cd8 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--dark.png and b/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--light.png b/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--light.png
index cadfa35ff0a63..44413dfa61cd9 100644
Binary files a/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--light.png and b/frontend/__snapshots__/scenes-other-settings--settings-web-vitals--light.png differ
diff --git a/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--dark.png b/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--dark.png
index 31d6746bc2752..bb50e05d84042 100644
Binary files a/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--dark.png and b/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--dark.png differ
diff --git a/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--light.png b/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--light.png
index 1a27f899049d4..7ca5d50818be3 100644
Binary files a/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--light.png and b/frontend/__snapshots__/scenes-other-toolbar--experiments-disabled-in-parent--light.png differ
diff --git a/frontend/src/layout/GlobalModals.tsx b/frontend/src/layout/GlobalModals.tsx
index 040510d4d532f..81bdae758064a 100644
--- a/frontend/src/layout/GlobalModals.tsx
+++ b/frontend/src/layout/GlobalModals.tsx
@@ -1,19 +1,16 @@
-import { LemonModal } from '@posthog/lemon-ui'
 import { actions, kea, path, reducers, useActions, useValues } from 'kea'
 import { ConfirmUpgradeModal } from 'lib/components/ConfirmUpgradeModal/ConfirmUpgradeModal'
 import { HedgehogBuddyWithLogic } from 'lib/components/HedgehogBuddy/HedgehogBuddyWithLogic'
 import { TimeSensitiveAuthenticationModal } from 'lib/components/TimeSensitiveAuthentication/TimeSensitiveAuthentication'
 import { UpgradeModal } from 'lib/components/UpgradeModal/UpgradeModal'
-import { Setup2FA } from 'scenes/authentication/Setup2FA'
+import { TwoFactorSetupModal } from 'scenes/authentication/TwoFactorSetupModal'
 import { CreateOrganizationModal } from 'scenes/organization/CreateOrganizationModal'
-import { membersLogic } from 'scenes/organization/membersLogic'
 import { CreateEnvironmentModal } from 'scenes/project/CreateEnvironmentModal'
 import { CreateProjectModal } from 'scenes/project/CreateProjectModal'
 import { SessionPlayerModal } from 'scenes/session-recordings/player/modal/SessionPlayerModal'
 import { inviteLogic } from 'scenes/settings/organization/inviteLogic'
 import { InviteModal } from 'scenes/settings/organization/InviteModal'
 import { PreviewingCustomCssModal } from 'scenes/themes/PreviewingCustomCssModal'
-import { userLogic } from 'scenes/userLogic'
 
 import type { globalModalsLogicType } from './GlobalModalsType'
 
@@ -59,7 +56,6 @@ export function GlobalModals(): JSX.Element {
         useActions(globalModalsLogic)
     const { isInviteModalShown } = useValues(inviteLogic)
     const { hideInviteModal } = useActions(inviteLogic)
-    const { user } = useValues(userLogic)
 
     return (
         <>
@@ -72,24 +68,7 @@ export function GlobalModals(): JSX.Element {
             <TimeSensitiveAuthenticationModal />
             <SessionPlayerModal />
             <PreviewingCustomCssModal />
-            {user && user.organization?.enforce_2fa && !user.is_2fa_enabled && (
-                <LemonModal title="Set up 2FA" closable={false}>
-                    <p>
-                        <b>Your organization requires you to set up 2FA.</b>
-                    </p>
-                    <p>
-                        <b>
-                            Use an authenticator app like Google Authenticator or 1Password to scan the QR code below.
-                        </b>
-                    </p>
-                    <Setup2FA
-                        onSuccess={() => {
-                            userLogic.actions.loadUser()
-                            membersLogic.actions.loadAllMembers()
-                        }}
-                    />
-                </LemonModal>
-            )}
+            <TwoFactorSetupModal />
             <HedgehogBuddyWithLogic />
         </>
     )
diff --git a/frontend/src/layout/navigation-3000/Navigation.scss b/frontend/src/layout/navigation-3000/Navigation.scss
index df5f78ab272c6..42bb779a54d82 100644
--- a/frontend/src/layout/navigation-3000/Navigation.scss
+++ b/frontend/src/layout/navigation-3000/Navigation.scss
@@ -175,7 +175,7 @@
 .Sidebar3000 {
     --sidebar-slider-padding: 0.125rem;
     --sidebar-horizontal-padding: 0.5rem;
-    --sidebar-row-height: 2.5rem;
+    --sidebar-row-height: 3rem;
     --sidebar-background: var(--bg-3000);
 
     position: relative;
@@ -533,8 +533,6 @@
 
     position: relative;
     display: flex;
-    flex-direction: column;
-    justify-content: center;
     width: 100%;
     height: 100%;
     color: inherit;
@@ -549,7 +547,9 @@
 }
 
 .SidebarListItem__link {
+    flex-direction: column;
     row-gap: 1px;
+    justify-content: center;
     padding: 0 var(--sidebar-horizontal-padding) 0 var(--sidebar-list-item-inset);
     color: inherit !important; // Disable link color
     .SidebarListItem[aria-disabled='true'] & {
@@ -558,17 +558,33 @@
 }
 
 .SidebarListItem__button {
+    flex-direction: row;
+    gap: 0.25rem;
     row-gap: 1px;
+    align-items: center;
     padding: 0 var(--sidebar-horizontal-padding) 0 var(--sidebar-list-item-inset);
+    font-size: 1.125rem; // Make icons bigger
     color: inherit !important; // Disable link color
     cursor: pointer;
 
     &:hover {
         background: var(--border-3000);
     }
+
+    .SidebarListItem__icon {
+        flex-shrink: 0;
+    }
+
+    .SidebarListItem__name {
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
 }
 
 .SidebarListItem__rename {
+    flex-direction: column;
+    justify-content: center;
+
     // Pseudo-elements don't work on inputs, so we use a wrapper div
     background: var(--bg-light);
 
diff --git a/frontend/src/layout/navigation-3000/components/SidebarList.tsx b/frontend/src/layout/navigation-3000/components/SidebarList.tsx
index 2b63b9a61e9c6..65cd05d65c4d4 100644
--- a/frontend/src/layout/navigation-3000/components/SidebarList.tsx
+++ b/frontend/src/layout/navigation-3000/components/SidebarList.tsx
@@ -232,7 +232,8 @@ function SidebarListItem({ item, validateName, active, style }: SidebarListItemP
     if (isItemClickable(item)) {
         content = (
             <li className="SidebarListItem__button" onClick={item.onClick}>
-                <h5>{item.name}</h5>
+                {item.icon && <div className="SidebarListItem__icon">{item.icon}</div>}
+                <h5 className="SidebarListItem__name">{item.name}</h5>
             </li>
         )
     } else if (!save || (!isItemTentative(item) && newName === null)) {
diff --git a/frontend/src/layout/navigation-3000/components/TopBar.scss b/frontend/src/layout/navigation-3000/components/TopBar.scss
index 6273642ace326..b797fd97bf2f8 100644
--- a/frontend/src/layout/navigation-3000/components/TopBar.scss
+++ b/frontend/src/layout/navigation-3000/components/TopBar.scss
@@ -155,7 +155,6 @@
 
 .TopBar3000__actions {
     display: flex;
-    flex-grow: 1;
     gap: 0.5rem;
     align-items: center;
     justify-content: flex-end;
diff --git a/frontend/src/layout/navigation-3000/components/TopBar.tsx b/frontend/src/layout/navigation-3000/components/TopBar.tsx
index e666bc094e911..0e9f9dde9cd5d 100644
--- a/frontend/src/layout/navigation-3000/components/TopBar.tsx
+++ b/frontend/src/layout/navigation-3000/components/TopBar.tsx
@@ -6,6 +6,8 @@ import clsx from 'clsx'
 import { useActions, useValues } from 'kea'
 import { router } from 'kea-router'
 import { EditableField } from 'lib/components/EditableField/EditableField'
+import { FlaggedFeature } from 'lib/components/FlaggedFeature'
+import { MetalyticsSummary } from 'lib/components/Metalytics/MetalyticsSummary'
 import { IconMenu } from 'lib/lemon-ui/icons'
 import { Link } from 'lib/lemon-ui/Link'
 import { Popover } from 'lib/lemon-ui/Popover/Popover'
@@ -101,7 +103,12 @@ export function TopBar(): JSX.Element | null {
                     )}
                     <Here breadcrumb={breadcrumbs[breadcrumbs.length - 1]} isOnboarding={isOnboarding} />
                 </div>
-                <div className="TopBar3000__actions" ref={setActionsContainer} />
+                <FlaggedFeature flag="metalytics">
+                    <div className="shrink-1">
+                        <MetalyticsSummary />
+                    </div>
+                </FlaggedFeature>
+                <div className="TopBar3000__actions border-danger" ref={setActionsContainer} />
             </div>
         </div>
     ) : null
diff --git a/frontend/src/layout/navigation-3000/navigationLogic.tsx b/frontend/src/layout/navigation-3000/navigationLogic.tsx
index be44236c6dc9b..6f6105aaa9c54 100644
--- a/frontend/src/layout/navigation-3000/navigationLogic.tsx
+++ b/frontend/src/layout/navigation-3000/navigationLogic.tsx
@@ -1,17 +1,18 @@
 import {
-    IconChat,
     IconCursorClick,
     IconDashboard,
     IconDatabase,
-    IconDecisionTree,
+    IconFeatures,
     IconGraph,
     IconHome,
     IconLive,
     IconLogomark,
     IconMegaphone,
+    IconMessage,
     IconNotebook,
     IconPeople,
     IconPieChart,
+    IconPlug,
     IconPlusSmall,
     IconRewindPlay,
     IconRocket,
@@ -429,6 +430,16 @@ export const navigation3000Logic = kea<navigation3000LogicType>([
                     })
                 }
 
+                if (featureFlags[FEATURE_FLAGS.FEATURE_MANAGEMENT_UI]) {
+                    sectionOne.splice(4, 0, {
+                        identifier: Scene.FeatureManagement,
+                        label: 'Features',
+                        icon: <IconFeatures />,
+                        logic: isUsingSidebar ? featureFlagsSidebarLogic : undefined,
+                        to: isUsingSidebar ? undefined : urls.featureManagement(),
+                    })
+                }
+
                 return [
                     sectionOne,
                     [
@@ -492,7 +503,7 @@ export const navigation3000Logic = kea<navigation3000LogicType>([
                         {
                             identifier: Scene.Surveys,
                             label: 'Surveys',
-                            icon: <IconChat />,
+                            icon: <IconMessage />,
                             to: urls.surveys(),
                         },
                         featureFlags[FEATURE_FLAGS.PRODUCT_INTRO_PAGES] !== 'test' || hasOnboardedFeatureFlags
@@ -506,13 +517,13 @@ export const navigation3000Logic = kea<navigation3000LogicType>([
                         {
                             identifier: Scene.DataWarehouse,
                             label: 'Data warehouse',
-                            icon: <IconServer />,
+                            icon: <IconDatabase />,
                             to: isUsingSidebar ? undefined : urls.dataWarehouse(),
                         },
                         featureFlags[FEATURE_FLAGS.SQL_EDITOR]
                             ? {
                                   identifier: Scene.SQLEditor,
-                                  label: 'Data warehouse 3000',
+                                  label: 'SQL Editor',
                                   icon: <IconServer />,
                                   to: urls.sqlEditor(),
                                   logic: editorSidebarLogic,
@@ -529,8 +540,8 @@ export const navigation3000Logic = kea<navigation3000LogicType>([
                         hasOnboardedAnyProduct
                             ? {
                                   identifier: Scene.Pipeline,
-                                  label: 'Data pipeline',
-                                  icon: <IconDecisionTree />,
+                                  label: 'Data pipelines',
+                                  icon: <IconPlug />,
                                   to: urls.pipeline(),
                               }
                             : null,
diff --git a/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx b/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx
index db89c7e5401b8..7701538ffd36c 100644
--- a/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx
+++ b/frontend/src/layout/navigation-3000/sidepanel/panels/SidePanelSupport.tsx
@@ -2,13 +2,13 @@ import {
     IconAI,
     IconChevronDown,
     IconDatabase,
-    IconDecisionTree,
     IconFeatures,
     IconGraph,
     IconHelmet,
     IconMap,
     IconMessage,
     IconPieChart,
+    IconPlug,
     IconRewindPlay,
     IconStack,
     IconTestTube,
@@ -74,7 +74,7 @@ const PRODUCTS = [
     {
         name: 'Data pipelines',
         slug: 'cdp',
-        icon: <IconDecisionTree className="text-[#2EA2D3] h-5 w-5" />,
+        icon: <IconPlug className="text-[#2EA2D3] h-5 w-5" />,
     },
     {
         name: 'Data warehouse',
diff --git a/frontend/src/layout/navigation-3000/sidepanel/panels/activity/SidePanelActivity.tsx b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/SidePanelActivity.tsx
index b49152b98c7a8..21a52abe26936 100644
--- a/frontend/src/layout/navigation-3000/sidepanel/panels/activity/SidePanelActivity.tsx
+++ b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/SidePanelActivity.tsx
@@ -31,6 +31,7 @@ import {
 import { ActivityScope, AvailableFeature } from '~/types'
 
 import { SidePanelPaneHeader } from '../../components/SidePanelPaneHeader'
+import { SidePanelActivityMetalytics } from './SidePanelActivityMetalytics'
 
 const SCROLL_TRIGGER_OFFSET = 100
 
@@ -126,11 +127,11 @@ export const SidePanelActivity = (): JSX.Element => {
             <SidePanelPaneHeader title="Team activity" />
             <PayGateMini
                 feature={AvailableFeature.AUDIT_LOGS}
-                className="flex flex-col overflow-hidden flex-1"
+                className="flex flex-col flex-1 overflow-hidden"
                 overrideShouldShowGate={user?.is_impersonated || !!featureFlags[FEATURE_FLAGS.AUDIT_LOGS_ACCESS]}
             >
-                <div className="flex flex-col overflow-hidden flex-1">
-                    <div className="shrink-0 mx-2">
+                <div className="flex flex-col flex-1 overflow-hidden">
+                    <div className="mx-2 shrink-0">
                         <LemonTabs
                             activeKey={activeTab as SidePanelActivityTab}
                             onChange={(key) => setActiveTab(key)}
@@ -143,76 +144,82 @@ export const SidePanelActivity = (): JSX.Element => {
                                     key: SidePanelActivityTab.All,
                                     label: 'All activity',
                                 },
+                                ...(featureFlags[FEATURE_FLAGS.METALYTICS]
+                                    ? [
+                                          {
+                                              key: SidePanelActivityTab.Metalytics,
+                                              label: 'Analytics',
+                                          },
+                                      ]
+                                    : []),
                             ]}
                         />
                     </div>
 
                     {/* Controls */}
-                    <div className="shrink-0 space-y-2 px-2 pb-2">
-                        {activeTab === SidePanelActivityTab.Unread ? (
-                            <>
-                                <LemonBanner type="info" dismissKey="notifications-introduction">
-                                    Notifications shows you changes others make to{' '}
-                                    <Link to={urls.savedInsights('history')}>Insights</Link> and{' '}
-                                    <Link to={urls.featureFlags('history')}>Feature Flags</Link> that you created. Come
-                                    join <Link to="https://posthog.com/community">our community forum</Link> and tell us
-                                    what else should be here!
-                                </LemonBanner>
+                    {activeTab === SidePanelActivityTab.Unread ? (
+                        <div className="px-2 pb-2 space-y-2 shrink-0">
+                            <LemonBanner type="info" dismissKey="notifications-introduction">
+                                Notifications shows you changes others make to{' '}
+                                <Link to={urls.savedInsights('history')}>Insights</Link> and{' '}
+                                <Link to={urls.featureFlags('history')}>Feature Flags</Link> that you created. Come join{' '}
+                                <Link to="https://posthog.com/community">our community forum</Link> and tell us what
+                                else should be here!
+                            </LemonBanner>
 
-                                <div className="flex items-center justify-between gap-2">
-                                    {toggleExtendedDescription}
-                                    {hasUnread ? (
-                                        <LemonButton type="secondary" onClick={() => markAllAsRead()}>
-                                            Mark all as read
-                                        </LemonButton>
-                                    ) : null}
-                                </div>
-                            </>
-                        ) : activeTab === SidePanelActivityTab.All ? (
                             <div className="flex items-center justify-between gap-2">
-                                <div className="flex items-center gap-2">
-                                    {toggleExtendedDescription}
-                                    {allActivityResponseLoading ? <Spinner textColored /> : null}
-                                </div>
+                                {toggleExtendedDescription}
+                                {hasUnread ? (
+                                    <LemonButton type="secondary" onClick={() => markAllAsRead()}>
+                                        Mark all as read
+                                    </LemonButton>
+                                ) : null}
+                            </div>
+                        </div>
+                    ) : activeTab === SidePanelActivityTab.All ? (
+                        <div className="flex items-center justify-between gap-2 px-2 pb-2 space-y-2 shrink-0">
+                            <div className="flex items-center gap-2">
+                                {toggleExtendedDescription}
+                                {allActivityResponseLoading ? <Spinner textColored /> : null}
+                            </div>
 
-                                <div className="flex items-center gap-2">
-                                    <span>Filter for activity on:</span>
-                                    <LemonSelect
-                                        size="small"
-                                        options={scopeMenuOptions}
-                                        placeholder="All activity"
-                                        value={(activeScopeMenuOption as ActivityScope) ?? undefined}
-                                        onChange={(value) =>
-                                            setFilters({
-                                                ...filters,
-                                                scope: value ?? undefined,
-                                                item_id: undefined,
-                                            })
-                                        }
-                                        dropdownMatchSelectWidth={false}
-                                    />
+                            <div className="flex items-center gap-2">
+                                <span>Filter for activity on:</span>
+                                <LemonSelect
+                                    size="small"
+                                    options={scopeMenuOptions}
+                                    placeholder="All activity"
+                                    value={(activeScopeMenuOption as ActivityScope) ?? undefined}
+                                    onChange={(value) =>
+                                        setFilters({
+                                            ...filters,
+                                            scope: value ?? undefined,
+                                            item_id: undefined,
+                                        })
+                                    }
+                                    dropdownMatchSelectWidth={false}
+                                />
 
-                                    <span>by</span>
-                                    <MemberSelect
-                                        value={filters?.user ?? null}
-                                        onChange={(user) =>
-                                            setFilters({
-                                                ...filters,
-                                                user: user?.id ?? undefined,
-                                            })
-                                        }
-                                    />
-                                </div>
+                                <span>by</span>
+                                <MemberSelect
+                                    value={filters?.user ?? null}
+                                    onChange={(user) =>
+                                        setFilters({
+                                            ...filters,
+                                            user: user?.id ?? undefined,
+                                        })
+                                    }
+                                />
                             </div>
-                        ) : null}
-                    </div>
+                        </div>
+                    ) : null}
 
                     <div className="flex flex-col flex-1 overflow-hidden" ref={contentRef} onScroll={handleScroll}>
                         <ScrollableShadows direction="vertical" innerClassName="p-2 space-y-px">
                             {activeTab === SidePanelActivityTab.Unread ? (
                                 <>
                                     {importantChangesLoading && !hasNotifications ? (
-                                        <LemonSkeleton className="my-2 h-12" repeat={10} fade />
+                                        <LemonSkeleton className="h-12 my-2" repeat={10} fade />
                                     ) : hasNotifications ? (
                                         notifications.map((logItem, index) => (
                                             <ActivityLogRow
@@ -222,7 +229,7 @@ export const SidePanelActivity = (): JSX.Element => {
                                             />
                                         ))
                                     ) : (
-                                        <div className="border rounded text-center border-dashed p-6 text-muted-alt">
+                                        <div className="p-6 text-center border border-dashed rounded text-muted-alt">
                                             You're all caught up!
                                         </div>
                                     )}
@@ -230,7 +237,7 @@ export const SidePanelActivity = (): JSX.Element => {
                             ) : activeTab === SidePanelActivityTab.All ? (
                                 <>
                                     {allActivityResponseLoading && !allActivity.length ? (
-                                        <LemonSkeleton className="my-2 h-12" repeat={10} fade />
+                                        <LemonSkeleton className="h-12 my-2" repeat={10} fade />
                                     ) : allActivity.length ? (
                                         <>
                                             {allActivity.map((logItem, index) => (
@@ -241,7 +248,7 @@ export const SidePanelActivity = (): JSX.Element => {
                                                 />
                                             ))}
 
-                                            <div className="m-4 h-10 flex items-center justify-center gap-2 text-muted-alt">
+                                            <div className="flex items-center justify-center h-10 gap-2 m-4 text-muted-alt">
                                                 {allActivityResponseLoading ? (
                                                     <>
                                                         <Spinner textColored /> Loading older activity
@@ -261,7 +268,7 @@ export const SidePanelActivity = (): JSX.Element => {
                                             </div>
                                         </>
                                     ) : (
-                                        <div className="border rounded text-center border-dashed p-6 flex flex-col gap-2 items-center">
+                                        <div className="flex flex-col items-center gap-2 p-6 text-center border border-dashed rounded">
                                             <span>No activity yet</span>
                                             {filters ? (
                                                 <LemonButton type="secondary" onClick={() => setFilters(null)}>
@@ -271,6 +278,8 @@ export const SidePanelActivity = (): JSX.Element => {
                                         </div>
                                     )}
                                 </>
+                            ) : activeTab === SidePanelActivityTab.Metalytics ? (
+                                <SidePanelActivityMetalytics />
                             ) : null}
                         </ScrollableShadows>
                     </div>
diff --git a/frontend/src/layout/navigation-3000/sidepanel/panels/activity/SidePanelActivityMetalytics.tsx b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/SidePanelActivityMetalytics.tsx
new file mode 100644
index 0000000000000..146cb6f96f5fa
--- /dev/null
+++ b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/SidePanelActivityMetalytics.tsx
@@ -0,0 +1,74 @@
+import { Spinner, Tooltip } from '@posthog/lemon-ui'
+import { useValues } from 'kea'
+import { humanizeScope } from 'lib/components/ActivityLog/humanizeActivity'
+import { metalyticsLogic } from 'lib/components/Metalytics/metalyticsLogic'
+import { ProfileBubbles } from 'lib/lemon-ui/ProfilePicture/ProfileBubbles'
+
+export function SidePanelActivityMetalytics(): JSX.Element {
+    const { scope, instanceId, viewCount, recentUserMembers, viewCountLoading, recentUsersLoading } =
+        useValues(metalyticsLogic)
+
+    if (!instanceId) {
+        return (
+            <p className="border-dashed ">
+                You can see internal analytics of how your Organization members are using PostHog for things such as
+                Dashboards, Insights, Playlists etc. Open an app to see the viewership data here.
+            </p>
+        )
+    }
+
+    const humanizedScope = `this ${scope ? humanizeScope(scope, true) : 'app'}`
+
+    return (
+        <div className="space-y-4 ">
+            <p>
+                You are viewing "meta" analytics of how your organization members are interacting with{' '}
+                <b>{humanizedScope}</b>.
+            </p>
+            <div className="flex flex-wrap gap-4">
+                <Tooltip
+                    title={`The total number of times ${humanizedScope} has been viewed by members of your organization.`}
+                    placement="top"
+                >
+                    <div className="flex-1 p-4 border rounded bg-bg-light min-w-40">
+                        <div className="text-sm text-muted">Views</div>
+                        <div className="text-2xl font-semibold">
+                            {viewCountLoading ? <Spinner /> : viewCount?.views ?? 0}
+                        </div>
+                    </div>
+                </Tooltip>
+
+                <Tooltip
+                    title={`The total number of unique organization members who have viewed ${humanizedScope}.`}
+                    placement="top"
+                >
+                    <div className="flex-1 p-4 border rounded bg-bg-light min-w-40">
+                        <div className="text-sm text-muted">Viewers</div>
+                        <div className="text-2xl font-semibold">
+                            {viewCountLoading ? <Spinner /> : viewCount?.users ?? 0}
+                        </div>
+                    </div>
+                </Tooltip>
+
+                <Tooltip title={`The most recent 30 users who have viewed ${humanizedScope}.`} placement="top">
+                    <div className="flex-1 p-4 border rounded bg-bg-light min-w-40">
+                        <div className="text-sm text-muted">Recent viewers (30 days)</div>
+                        {recentUsersLoading ? (
+                            <Spinner />
+                        ) : (
+                            <ProfileBubbles
+                                className="mt-2"
+                                people={recentUserMembers.map((member) => ({
+                                    email: member.user.email,
+                                    name: member.user.first_name,
+                                    title: member.user.email,
+                                }))}
+                                limit={3}
+                            />
+                        )}
+                    </div>
+                </Tooltip>
+            </div>
+        </div>
+    )
+}
diff --git a/frontend/src/layout/navigation-3000/sidepanel/panels/activity/activityForSceneLogic.ts b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/activityForSceneLogic.ts
index 180461c465996..641c0900638ef 100644
--- a/frontend/src/layout/navigation-3000/sidepanel/panels/activity/activityForSceneLogic.ts
+++ b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/activityForSceneLogic.ts
@@ -37,6 +37,7 @@ export const activityForSceneLogic = kea<activityForSceneLogicType>([
     connect({
         values: [sceneLogic, ['sceneConfig']],
     }),
+
     selectors({
         sceneActivityFilters: [
             (s) => [
diff --git a/frontend/src/layout/navigation-3000/sidepanel/panels/activity/sidePanelActivityLogic.tsx b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/sidePanelActivityLogic.tsx
index 69554124d4fbf..244e42c52d936 100644
--- a/frontend/src/layout/navigation-3000/sidepanel/panels/activity/sidePanelActivityLogic.tsx
+++ b/frontend/src/layout/navigation-3000/sidepanel/panels/activity/sidePanelActivityLogic.tsx
@@ -10,6 +10,7 @@ import { toParams } from 'lib/utils'
 import posthog from 'posthog-js'
 import { projectLogic } from 'scenes/projectLogic'
 
+import { sidePanelStateLogic } from '../../sidePanelStateLogic'
 import { ActivityFilters, activityForSceneLogic } from './activityForSceneLogic'
 import type { sidePanelActivityLogicType } from './sidePanelActivityLogicType'
 
@@ -29,12 +30,14 @@ export interface ChangesResponse {
 export enum SidePanelActivityTab {
     Unread = 'unread',
     All = 'all',
+    Metalytics = 'metalytics',
 }
 
 export const sidePanelActivityLogic = kea<sidePanelActivityLogicType>([
     path(['scenes', 'navigation', 'sidepanel', 'sidePanelActivityLogic']),
     connect({
         values: [activityForSceneLogic, ['sceneActivityFilters'], projectLogic, ['currentProjectId']],
+        actions: [sidePanelStateLogic, ['openSidePanel']],
     }),
     actions({
         togglePolling: (pageIsVisible: boolean) => ({ pageIsVisible }),
@@ -171,7 +174,7 @@ export const sidePanelActivityLogic = kea<sidePanelActivityLogicType>([
         ],
     })),
 
-    listeners(({ values, actions }) => ({
+    listeners(({ values, actions, cache }) => ({
         setActiveTab: ({ tab }) => {
             if (tab === SidePanelActivityTab.All && !values.allActivityResponseLoading) {
                 actions.loadAllActivity()
@@ -183,6 +186,18 @@ export const sidePanelActivityLogic = kea<sidePanelActivityLogicType>([
                 actions.loadOlderActivity()
             }
         },
+        openSidePanel: ({ options }) => {
+            if (options) {
+                actions.setActiveTab(options as SidePanelActivityTab)
+            }
+        },
+        togglePolling: ({ pageIsVisible }) => {
+            if (pageIsVisible) {
+                actions.loadImportantChanges()
+            } else {
+                clearTimeout(cache.pollTimeout)
+            }
+        },
     })),
     selectors({
         allActivity: [
diff --git a/frontend/src/layout/navigation-3000/types.ts b/frontend/src/layout/navigation-3000/types.ts
index 3f79f6dbda42f..a941e7dfaad74 100644
--- a/frontend/src/layout/navigation-3000/types.ts
+++ b/frontend/src/layout/navigation-3000/types.ts
@@ -151,4 +151,5 @@ export interface TentativeListItem {
 export interface ButtonListItem extends BasicListItem {
     key: '__button__'
     onClick: () => void
+    icon?: JSX.Element
 }
diff --git a/frontend/src/layout/navigation/ProjectNotice.tsx b/frontend/src/layout/navigation/ProjectNotice.tsx
index 5a0a9c4dd28ce..8d4df0246a3a0 100644
--- a/frontend/src/layout/navigation/ProjectNotice.tsx
+++ b/frontend/src/layout/navigation/ProjectNotice.tsx
@@ -1,4 +1,5 @@
 import { IconGear, IconPlus } from '@posthog/icons'
+import { Spinner } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { dayjs } from 'lib/dayjs'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
@@ -22,17 +23,29 @@ interface ProjectNoticeBlueprint {
     closeable?: boolean
 }
 
-function CountDown({ datetime }: { datetime: dayjs.Dayjs }): JSX.Element {
+function CountDown({ datetime, callback }: { datetime: dayjs.Dayjs; callback?: () => void }): JSX.Element {
     const [now, setNow] = useState(dayjs())
 
+    // Format the time difference as 00:00:00
+    const duration = dayjs.duration(datetime.diff(now))
+    const pastCountdown = duration.seconds() < 0
+
+    const countdown = pastCountdown
+        ? 'Expired'
+        : duration.hours() > 0
+        ? duration.format('HH:mm:ss')
+        : duration.format('mm:ss')
+
     useEffect(() => {
         const interval = setInterval(() => setNow(dayjs()), 1000)
         return () => clearInterval(interval)
     }, [])
 
-    // Format the time difference as 00:00:00
-    const duration = dayjs.duration(datetime.diff(now))
-    const countdown = duration.hours() > 0 ? duration.format('HH:mm:ss') : duration.format('mm:ss')
+    useEffect(() => {
+        if (pastCountdown) {
+            callback?.()
+        }
+    }, [pastCountdown])
 
     return <>{countdown}</>
 }
@@ -40,8 +53,8 @@ function CountDown({ datetime }: { datetime: dayjs.Dayjs }): JSX.Element {
 export function ProjectNotice(): JSX.Element | null {
     const { projectNoticeVariant } = useValues(navigationLogic)
     const { currentOrganization } = useValues(organizationLogic)
-    const { logout } = useActions(userLogic)
-    const { user } = useValues(userLogic)
+    const { logout, loadUser } = useActions(userLogic)
+    const { user, userLoading } = useValues(userLogic)
     const { closeProjectNotice } = useActions(navigationLogic)
     const { showInviteModal } = useActions(inviteLogic)
     const { requestVerificationLink } = useActions(verifyEmailLogic)
@@ -124,7 +137,14 @@ export function ProjectNotice(): JSX.Element | null {
                     You are currently logged in as a customer.{' '}
                     {user?.is_impersonated_until && (
                         <>
-                            Expires in <CountDown datetime={dayjs(user.is_impersonated_until)} />
+                            Expires in <CountDown datetime={dayjs(user.is_impersonated_until)} callback={loadUser} />
+                            {userLoading ? (
+                                <Spinner />
+                            ) : (
+                                <Link className="ml-2" onClick={() => loadUser()}>
+                                    Refresh
+                                </Link>
+                            )}
                         </>
                     )}
                 </>
diff --git a/frontend/src/lib/api.mock.ts b/frontend/src/lib/api.mock.ts
index 0dacdcfa74554..e6dac16290e92 100644
--- a/frontend/src/lib/api.mock.ts
+++ b/frontend/src/lib/api.mock.ts
@@ -84,6 +84,7 @@ export const MOCK_DEFAULT_TEAM: TeamType = {
     autocapture_web_vitals_opt_in: false,
     autocapture_exceptions_errors_to_ignore: [],
     effective_membership_level: OrganizationMembershipLevel.Admin,
+    user_access_level: 'admin',
     access_control: true,
     has_group_types: true,
     primary_dashboard: 1,
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 7be5df3d764d6..f1497f937c334 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -54,6 +54,7 @@ import {
     ExternalDataSourceSyncSchema,
     ExternalDataSourceType,
     FeatureFlagAssociatedRoleType,
+    FeatureFlagStatusResponse,
     FeatureFlagType,
     Group,
     GroupListParams,
@@ -424,8 +425,8 @@ class ApiRequest {
         return this.events(teamId).addPathComponent(id)
     }
 
-    public tags(teamId?: TeamType['id']): ApiRequest {
-        return this.projectsDetail(teamId).addPathComponent('tags')
+    public tags(projectId?: ProjectType['id']): ApiRequest {
+        return this.projectsDetail(projectId).addPathComponent('tags')
     }
 
     // # Data management
@@ -520,8 +521,11 @@ class ApiRequest {
         return this.dashboards(teamId).addPathComponent(dashboardId)
     }
 
-    public dashboardCollaborators(dashboardId: DashboardType['id'], teamId?: TeamType['id']): ApiRequest {
-        return this.dashboardsDetail(dashboardId, teamId).addPathComponent('collaborators')
+    public dashboardCollaborators(
+        dashboardId: DashboardType['id'],
+        projectId: ProjectType['id'] = ApiConfig.getCurrentProjectId() // Collaborators endpoint is project-level, not team-level
+    ): ApiRequest {
+        return this.dashboardsDetail(dashboardId, projectId).addPathComponent('collaborators')
     }
 
     public dashboardSharing(dashboardId: DashboardType['id'], teamId?: TeamType['id']): ApiRequest {
@@ -531,9 +535,9 @@ class ApiRequest {
     public dashboardCollaboratorsDetail(
         dashboardId: DashboardType['id'],
         userUuid: UserType['uuid'],
-        teamId?: TeamType['id']
+        projectId?: ProjectType['id']
     ): ApiRequest {
-        return this.dashboardCollaborators(dashboardId, teamId).addPathComponent(userUuid)
+        return this.dashboardCollaborators(dashboardId, projectId).addPathComponent(userUuid)
     }
 
     // # Dashboard templates
@@ -663,6 +667,13 @@ class ApiRequest {
             )
     }
 
+    public featureFlagStatus(teamId: TeamType['id'], featureFlagId: FeatureFlagType['id']): ApiRequest {
+        return this.projectsDetail(teamId)
+            .addPathComponent('feature_flags')
+            .addPathComponent(String(featureFlagId))
+            .addPathComponent('status')
+    }
+
     public featureFlagCreateScheduledChange(teamId: TeamType['id']): ApiRequest {
         return this.projectsDetail(teamId).addPathComponent('scheduled_changes')
     }
@@ -834,9 +845,9 @@ class ApiRequest {
         return apiRequest
     }
 
-    // Chat
-    public chat(teamId?: TeamType['id']): ApiRequest {
-        return this.environmentsDetail(teamId).addPathComponent('query').addPathComponent('chat')
+    // Conversations
+    public conversations(teamId?: TeamType['id']): ApiRequest {
+        return this.environmentsDetail(teamId).addPathComponent('conversations')
     }
 
     // Notebooks
@@ -921,6 +932,10 @@ class ApiRequest {
         return await api.update(this.assembleFullUrl(), options?.data, options)
     }
 
+    public async put(options?: ApiMethodOptions & { data: any }): Promise<any> {
+        return await api.put(this.assembleFullUrl(), options?.data, options)
+    }
+
     public async create(options?: ApiMethodOptions & { data: any }): Promise<any> {
         return await api.create(this.assembleFullUrl(), options?.data, options)
     }
@@ -1038,6 +1053,12 @@ const api = {
         ): Promise<{ scheduled_change: ScheduledChangeType }> {
             return await new ApiRequest().featureFlagDeleteScheduledChange(teamId, scheduledChangeId).delete()
         },
+        async getStatus(
+            teamId: TeamType['id'],
+            featureFlagId: FeatureFlagType['id']
+        ): Promise<FeatureFlagStatusResponse> {
+            return await new ApiRequest().featureFlagStatus(teamId, featureFlagId).get()
+        },
     },
 
     organizationFeatureFlags: {
@@ -1279,8 +1300,8 @@ const api = {
     },
 
     tags: {
-        async list(teamId: TeamType['id'] = ApiConfig.getCurrentTeamId()): Promise<string[]> {
-            return new ApiRequest().tags(teamId).get()
+        async list(projectId: TeamType['id'] = ApiConfig.getCurrentProjectId()): Promise<string[]> {
+            return new ApiRequest().tags(projectId).get()
         },
     },
 
@@ -2526,12 +2547,10 @@ const api = {
         })
     },
 
-    chatURL: (): string => {
-        return new ApiRequest().chat().assembleFullUrl()
-    },
-
-    async chat(data: any): Promise<Response> {
-        return await api.createResponse(this.chatURL(), data)
+    conversations: {
+        async create(data: { content: string; conversation?: string | null }): Promise<Response> {
+            return api.createResponse(new ApiRequest().conversations().assembleFullUrl(), data)
+        },
     },
 
     /** Fetch data from specified URL. The result already is JSON-parsed. */
@@ -2554,14 +2573,19 @@ const api = {
         })
     },
 
-    async update(url: string, data: any, options?: ApiMethodOptions): Promise<any> {
+    async _update<T = any, P = any>(
+        method: 'PATCH' | 'PUT',
+        url: string,
+        data: P,
+        options?: ApiMethodOptions
+    ): Promise<T> {
         url = prepareUrl(url)
         ensureProjectIdNotInvalid(url)
         const isFormData = data instanceof FormData
 
-        const response = await handleFetch(url, 'PATCH', async () => {
+        const response = await handleFetch(url, method, async () => {
             return await fetch(url, {
-                method: 'PATCH',
+                method: method,
                 headers: {
                     ...objectClean(options?.headers ?? {}),
                     ...(isFormData ? {} : { 'Content-Type': 'application/json' }),
@@ -2576,7 +2600,15 @@ const api = {
         return await getJSONOrNull(response)
     },
 
-    async create(url: string, data?: any, options?: ApiMethodOptions): Promise<any> {
+    async update<T = any, P = any>(url: string, data: P, options?: ApiMethodOptions): Promise<T> {
+        return api._update('PATCH', url, data, options)
+    },
+
+    async put<T = any, P = any>(url: string, data: P, options?: ApiMethodOptions): Promise<T> {
+        return api._update('PUT', url, data, options)
+    },
+
+    async create<T = any, P = any>(url: string, data?: P, options?: ApiMethodOptions): Promise<T> {
         const res = await api.createResponse(url, data, options)
         return await getJSONOrNull(res)
     },
diff --git a/frontend/src/lib/components/AuthorizedUrlList/AuthorizedUrlList.tsx b/frontend/src/lib/components/AuthorizedUrlList/AuthorizedUrlList.tsx
index 1169702c255fa..aa95376c5fa9c 100644
--- a/frontend/src/lib/components/AuthorizedUrlList/AuthorizedUrlList.tsx
+++ b/frontend/src/lib/components/AuthorizedUrlList/AuthorizedUrlList.tsx
@@ -186,7 +186,7 @@ export function AuthorizedUrlList({
                                                     type === AuthorizedUrlListType.TOOLBAR_URLS
                                                         ? launchUrl(keyedURL.url)
                                                         : // other urls are simply opened directly
-                                                          keyedURL.url + query
+                                                          `${keyedURL.url}${query ? query : ''}`
                                                 }
                                                 targetBlank
                                                 tooltip={
diff --git a/frontend/src/lib/components/Cards/TextCard/TextCard.tsx b/frontend/src/lib/components/Cards/TextCard/TextCard.tsx
index 34c889fd00cee..698530f338d4a 100644
--- a/frontend/src/lib/components/Cards/TextCard/TextCard.tsx
+++ b/frontend/src/lib/components/Cards/TextCard/TextCard.tsx
@@ -34,8 +34,8 @@ interface TextCardBodyProps extends Pick<React.HTMLAttributes<HTMLDivElement>, '
 
 export function TextContent({ text, closeDetails, className }: TextCardBodyProps): JSX.Element {
     return (
-        <div className={clsx('p-2 w-full overflow-auto', className)} onClick={() => closeDetails?.()}>
-            <LemonMarkdown>{text}</LemonMarkdown>
+        <div className={clsx('w-full', className)} onClick={() => closeDetails?.()}>
+            <LemonMarkdown className="overflow-auto">{text}</LemonMarkdown>
         </div>
     )
 }
@@ -143,7 +143,7 @@ export function TextCardInternal(
             )}
 
             <div className="TextCard__body w-full">
-                <TextContent text={text.body} className="p-4" />
+                <TextContent text={text.body} className="p-4 pr-14" />
             </div>
 
             {showResizeHandles && (
diff --git a/frontend/src/lib/components/CompareFilter/CompareFilter.tsx b/frontend/src/lib/components/CompareFilter/CompareFilter.tsx
index 23999b9dce4db..3cb57cd84642a 100644
--- a/frontend/src/lib/components/CompareFilter/CompareFilter.tsx
+++ b/frontend/src/lib/components/CompareFilter/CompareFilter.tsx
@@ -1,29 +1,31 @@
 import { LemonSelect } from '@posthog/lemon-ui'
-import { useActions, useValues } from 'kea'
 import { RollingDateRangeFilter } from 'lib/components/DateFilter/RollingDateRangeFilter'
 import { dateFromToText } from 'lib/utils'
 import { useEffect, useState } from 'react'
-import { insightLogic } from 'scenes/insights/insightLogic'
-import { insightVizDataLogic } from 'scenes/insights/insightVizDataLogic'
 
-export function CompareFilter(): JSX.Element | null {
-    const { insightProps, canEditInsight } = useValues(insightLogic)
+import { CompareFilter as CompareFilterType } from '~/queries/schema'
 
-    const { compareFilter, supportsCompare } = useValues(insightVizDataLogic(insightProps))
-    const { updateCompareFilter } = useActions(insightVizDataLogic(insightProps))
+type CompareFilterProps = {
+    compareFilter?: CompareFilterType | null
+    updateCompareFilter: (compareFilter: CompareFilterType) => void
+    disabled?: boolean
+}
 
+export function CompareFilter({
+    compareFilter,
+    updateCompareFilter,
+    disabled,
+}: CompareFilterProps): JSX.Element | null {
     // This keeps the state of the rolling date range filter, even when different drop down options are selected
     // The default value for this is one month
     const [tentativeCompareTo, setTentativeCompareTo] = useState<string>(compareFilter?.compare_to || '-1m')
 
-    const disabled: boolean = !canEditInsight || !supportsCompare
-
     useEffect(() => {
         const newCompareTo = compareFilter?.compare_to
         if (!!newCompareTo && tentativeCompareTo != newCompareTo) {
             setTentativeCompareTo(newCompareTo)
         }
-    }, [compareFilter?.compare_to])
+    }, [compareFilter?.compare_to]) // eslint-disable-line react-hooks/exhaustive-deps
 
     // Hide compare filter control when disabled to avoid states where control is "disabled but checked"
     if (disabled) {
diff --git a/frontend/src/lib/components/DefinitionPopover/DefinitionPopoverContents.tsx b/frontend/src/lib/components/DefinitionPopover/DefinitionPopoverContents.tsx
index f1d7410f53ca0..e9ef0b32bbb80 100644
--- a/frontend/src/lib/components/DefinitionPopover/DefinitionPopoverContents.tsx
+++ b/frontend/src/lib/components/DefinitionPopover/DefinitionPopoverContents.tsx
@@ -24,6 +24,7 @@ import { DataWarehouseTableForInsight } from 'scenes/data-warehouse/types'
 
 import { ActionType, CohortType, EventDefinition, PropertyDefinition } from '~/types'
 
+import { HogQLDropdown } from '../HogQLDropdown/HogQLDropdown'
 import { taxonomicFilterLogic } from '../TaxonomicFilter/taxonomicFilterLogic'
 import { TZLabel } from '../TZLabel'
 
@@ -291,8 +292,21 @@ function DefinitionView({ group }: { group: TaxonomicFilterGroup }): JSX.Element
             label: column.name + ' (' + column.type + ')',
             value: column.name,
         }))
+        const hogqlOption = { label: 'HogQL Expression', value: '' }
         const itemValue = localDefinition ? group?.getValue?.(localDefinition) : null
 
+        const isUsingHogQLExpression = (value: string | undefined): boolean => {
+            if (value === undefined) {
+                return false
+            }
+            const column = Object.values(_definition.fields ?? {}).find((n) => n.name == value)
+            return !column
+        }
+
+        const distinct_id_field_value =
+            'distinct_id_field' in localDefinition ? localDefinition.distinct_id_field : undefined
+        const timestamp_field_value = 'timestamp_field' in localDefinition ? localDefinition.timestamp_field : undefined
+
         return (
             <form className="definition-popover-data-warehouse-schema-form">
                 <div className="flex flex-col justify-between gap-4">
@@ -310,23 +324,33 @@ function DefinitionView({ group }: { group: TaxonomicFilterGroup }): JSX.Element
                             <span className="label-text">Distinct ID field</span>
                         </label>
                         <LemonSelect
-                            value={
-                                'distinct_id_field' in localDefinition ? localDefinition.distinct_id_field : undefined
-                            }
-                            options={columnOptions}
+                            value={isUsingHogQLExpression(distinct_id_field_value) ? '' : distinct_id_field_value}
+                            options={[...columnOptions, hogqlOption]}
                             onChange={(value) => setLocalDefinition({ distinct_id_field: value })}
                         />
+                        {isUsingHogQLExpression(distinct_id_field_value) && (
+                            <HogQLDropdown
+                                hogQLValue={distinct_id_field_value || ''}
+                                tableName={_definition.name}
+                                onHogQLValueChange={(value) => setLocalDefinition({ distinct_id_field: value })}
+                            />
+                        )}
 
                         <label className="definition-popover-edit-form-label" htmlFor="Timestamp Field">
                             <span className="label-text">Timestamp field</span>
                         </label>
                         <LemonSelect
-                            value={
-                                ('timestamp_field' in localDefinition && localDefinition.timestamp_field) || undefined
-                            }
-                            options={columnOptions}
+                            value={isUsingHogQLExpression(timestamp_field_value) ? '' : timestamp_field_value}
+                            options={[...columnOptions, hogqlOption]}
                             onChange={(value) => setLocalDefinition({ timestamp_field: value })}
                         />
+                        {isUsingHogQLExpression(timestamp_field_value) && (
+                            <HogQLDropdown
+                                hogQLValue={timestamp_field_value || ''}
+                                tableName={_definition.name}
+                                onHogQLValueChange={(value) => setLocalDefinition({ timestamp_field: value })}
+                            />
+                        )}
                     </DefinitionPopover.Section>
                     <div className="flex justify-end">
                         <LemonButton
diff --git a/frontend/src/lib/components/HogQLDropdown/HogQLDropdown.tsx b/frontend/src/lib/components/HogQLDropdown/HogQLDropdown.tsx
new file mode 100644
index 0000000000000..63e358ce8a02e
--- /dev/null
+++ b/frontend/src/lib/components/HogQLDropdown/HogQLDropdown.tsx
@@ -0,0 +1,52 @@
+import { LemonButton, LemonDropdown } from '@posthog/lemon-ui'
+import clsx from 'clsx'
+import { useState } from 'react'
+
+import { NodeKind } from '~/queries/schema'
+
+import { HogQLEditor } from '../HogQLEditor/HogQLEditor'
+
+export const HogQLDropdown = ({
+    hogQLValue,
+    onHogQLValueChange,
+    tableName,
+    className = '',
+}: {
+    hogQLValue: string
+    tableName: string
+    className?: string
+    onHogQLValueChange: (hogQLValue: string) => void
+}): JSX.Element => {
+    const [isHogQLDropdownVisible, setIsHogQLDropdownVisible] = useState(false)
+
+    return (
+        <div className={clsx('flex-auto overflow-hidden', className)}>
+            <LemonDropdown
+                visible={isHogQLDropdownVisible}
+                closeOnClickInside={false}
+                onClickOutside={() => setIsHogQLDropdownVisible(false)}
+                overlay={
+                    // eslint-disable-next-line react/forbid-dom-props
+                    <div className="w-120" style={{ maxWidth: 'max(60vw, 20rem)' }}>
+                        <HogQLEditor
+                            value={hogQLValue}
+                            metadataSource={{ kind: NodeKind.HogQLQuery, query: `SELECT * FROM ${tableName}` }}
+                            onChange={(currentValue) => {
+                                onHogQLValueChange(currentValue)
+                                setIsHogQLDropdownVisible(false)
+                            }}
+                        />
+                    </div>
+                }
+            >
+                <LemonButton
+                    fullWidth
+                    type="secondary"
+                    onClick={() => setIsHogQLDropdownVisible(!isHogQLDropdownVisible)}
+                >
+                    <code>{hogQLValue}</code>
+                </LemonButton>
+            </LemonDropdown>
+        </div>
+    )
+}
diff --git a/frontend/src/lib/components/HogQLEditor/HogQLEditor.tsx b/frontend/src/lib/components/HogQLEditor/HogQLEditor.tsx
index 9d0cf1f42b893..95b809878a98d 100644
--- a/frontend/src/lib/components/HogQLEditor/HogQLEditor.tsx
+++ b/frontend/src/lib/components/HogQLEditor/HogQLEditor.tsx
@@ -58,7 +58,7 @@ export function HogQLEditor({
                     {placeholder ??
                         (metadataSource && isActorsQuery(metadataSource)
                             ? "Enter HogQL expression, such as:\n- properties.$geoip_country_name\n- toInt(properties.$browser_version) * 10\n- concat(properties.name, ' <', properties.email, '>')\n- is_identified ? 'user' : 'anon'"
-                            : "Enter HogQL Expression, such as:\n- properties.$current_url\n- person.properties.$geoip_country_name\n- toInt(properties.`Long Field Name`) * 10\n- concat(event, ' ', distinct_id)\n- if(1 < 2, 'small', 'large')")}
+                            : "Enter HogQL Expression, such as:\n- properties.$current_url\n- person.properties.$geoip_country_name\n- pdi.person.properties.email\n- toInt(properties.`Long Field Name`) * 10\n- concat(event, ' ', distinct_id)\n- if(1 < 2, 'small', 'large')")}
                 </pre>
             </div>
             <LemonButton
diff --git a/frontend/src/lib/components/IntervalFilter/IntervalFilter.tsx b/frontend/src/lib/components/IntervalFilter/IntervalFilter.tsx
index 522ba901a977e..d0764df2ad599 100644
--- a/frontend/src/lib/components/IntervalFilter/IntervalFilter.tsx
+++ b/frontend/src/lib/components/IntervalFilter/IntervalFilter.tsx
@@ -1,4 +1,5 @@
-import { LemonSelect, LemonSelectOption } from '@posthog/lemon-ui'
+import { IconPin } from '@posthog/icons'
+import { LemonButton, LemonSelect, LemonSelectOption } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { insightLogic } from 'scenes/insights/insightLogic'
 import { insightVizDataLogic } from 'scenes/insights/insightVizDataLogic'
@@ -12,27 +13,43 @@ interface IntervalFilterProps {
 
 export function IntervalFilter({ disabled }: IntervalFilterProps): JSX.Element {
     const { insightProps } = useValues(insightLogic)
-    const { interval, enabledIntervals } = useValues(insightVizDataLogic(insightProps))
-    const { updateQuerySource } = useActions(insightVizDataLogic(insightProps))
+    const { interval, enabledIntervals, isIntervalManuallySet } = useValues(insightVizDataLogic(insightProps))
+    const { updateQuerySource, setIsIntervalManuallySet } = useActions(insightVizDataLogic(insightProps))
 
     return (
         <>
             <span>
                 <span className="hidden md:inline">grouped </span>by
             </span>
-            <IntervalFilterStandalone
-                disabled={disabled}
-                interval={interval || 'day'}
-                onIntervalChange={(value) => {
-                    updateQuerySource({ interval: value } as Partial<InsightQueryNode>)
-                }}
-                options={Object.entries(enabledIntervals).map(([value, { label, disabledReason, hidden }]) => ({
-                    value: value as IntervalType,
-                    label,
-                    hidden,
-                    disabledReason,
-                }))}
-            />
+            {isIntervalManuallySet ? (
+                <LemonButton
+                    type="secondary"
+                    onClick={() => {
+                        setIsIntervalManuallySet(false)
+                    }}
+                    tooltip="Unpin interval"
+                    className="flex-1"
+                    center
+                    size="small"
+                    icon={<IconPin color="var(--content-warning)" />}
+                >
+                    {interval || 'day'}
+                </LemonButton>
+            ) : (
+                <IntervalFilterStandalone
+                    disabled={disabled}
+                    interval={interval || 'day'}
+                    onIntervalChange={(value) => {
+                        updateQuerySource({ interval: value } as Partial<InsightQueryNode>)
+                    }}
+                    options={Object.entries(enabledIntervals).map(([value, { label, disabledReason, hidden }]) => ({
+                        value: value as IntervalType,
+                        label,
+                        hidden,
+                        disabledReason,
+                    }))}
+                />
+            )}
         </>
     )
 }
diff --git a/frontend/src/lib/components/JSSnippet.tsx b/frontend/src/lib/components/JSSnippet.tsx
index 0d93f5d71f845..50ccf855ffcb3 100644
--- a/frontend/src/lib/components/JSSnippet.tsx
+++ b/frontend/src/lib/components/JSSnippet.tsx
@@ -6,7 +6,7 @@ import { apiHostOrigin } from 'lib/utils/apiHost'
 import posthog from 'posthog-js'
 import { teamLogic } from 'scenes/teamLogic'
 
-export function snippetFunctions(): string {
+function snippetFunctions(arrayJs = '/static/array.js'): string {
     const methods: string[] = []
     const posthogPrototype = Object.getPrototypeOf(posthog)
     for (const key of Object.getOwnPropertyNames(posthogPrototype)) {
@@ -20,23 +20,24 @@ export function snippetFunctions(): string {
     }
     const snippetMethods = methods.join(' ')
 
-    return `!function(t,e){var o,n,p,r;e.__SV||(window.posthog=e,e._i=[],e.init=function(i,s,a){function g(t,e){var o=e.split(".");2==o.length&&(t=t[o[0]],e=o[1]),t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}}(p=t.createElement("script")).type="text/javascript",p.crossOrigin="anonymous",p.async=!0,p.src=s.api_host.replace(".i.posthog.com","-assets.i.posthog.com")+"/static/array.js",(r=t.getElementsByTagName("script")[0]).parentNode.insertBefore(p,r);var u=e;for(void 0!==a?u=e[a]=[]:a="posthog",u.people=u.people||[],u.toString=function(t){var e="posthog";return"posthog"!==a&&(e+="."+a),t||(e+=" (stub)"),e},u.people.toString=function(){return u.toString(1)+".people (stub)"},o="${snippetMethods}".split(" "),n=0;n<o.length;n++)g(u,o[n]);e._i.push([i,s,a])},e.__SV=1)}(document,window.posthog||[]);`
+    return `!function(t,e){var o,n,p,r;e.__SV||(window.posthog=e,e._i=[],e.init=function(i,s,a){function g(t,e){var o=e.split(".");2==o.length&&(t=t[o[0]],e=o[1]),t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}}(p=t.createElement("script")).type="text/javascript",p.crossOrigin="anonymous",p.async=!0,p.src=s.api_host.replace(".i.posthog.com","-assets.i.posthog.com")+"${arrayJs}",(r=t.getElementsByTagName("script")[0]).parentNode.insertBefore(p,r);var u=e;for(void 0!==a?u=e[a]=[]:a="posthog",u.people=u.people||[],u.toString=function(t){var e="posthog";return"posthog"!==a&&(e+="."+a),t||(e+=" (stub)"),e},u.people.toString=function(){return u.toString(1)+".people (stub)"},o="${snippetMethods}".split(" "),n=0;n<o.length;n++)g(u,o[n]);e._i.push([i,s,a])},e.__SV=1)}(document,window.posthog||[]);`
 }
 
-export function useJsSnippet(indent = 0): string {
+export function useJsSnippet(indent = 0, arrayJs?: string): string {
     const { currentTeam } = useValues(teamLogic)
     const { featureFlags } = useValues(featureFlagLogic)
     const isPersonProfilesDisabled = featureFlags[FEATURE_FLAGS.PERSONLESS_EVENTS_NOT_SUPPORTED]
 
     return [
         '<script>',
-        `    ${snippetFunctions()}`,
-        `    posthog.init('${currentTeam?.api_token}',{api_host:'${apiHostOrigin()}', ${
+        `    ${snippetFunctions(arrayJs)}`,
+        `    posthog.init('${currentTeam?.api_token}', {
+        api_host:'${apiHostOrigin()}'${
             isPersonProfilesDisabled
                 ? ``
-                : `person_profiles: 'identified_only' // or 'always' to create profiles for anonymous users as well`
+                : `,\n        person_profiles: 'identified_only' // or 'always' to create profiles for anonymous users as well`
         }
-        })`,
+    })`,
         '</script>',
     ]
         .map((x) => ' '.repeat(indent) + x)
@@ -48,3 +49,11 @@ export function JSSnippet(): JSX.Element {
 
     return <CodeSnippet language={Language.HTML}>{snippet}</CodeSnippet>
 }
+
+export function JSSnippetV2(): JSX.Element {
+    const { currentTeam } = useValues(teamLogic)
+
+    const snippet = useJsSnippet(0, `/array/${currentTeam?.api_token}/array.js`)
+
+    return <CodeSnippet language={Language.HTML}>{snippet}</CodeSnippet>
+}
diff --git a/frontend/src/lib/components/Metalytics/MetalyticsSummary.tsx b/frontend/src/lib/components/Metalytics/MetalyticsSummary.tsx
new file mode 100644
index 0000000000000..67230d017641c
--- /dev/null
+++ b/frontend/src/lib/components/Metalytics/MetalyticsSummary.tsx
@@ -0,0 +1,39 @@
+import { IconPulse } from '@posthog/icons'
+import { LemonBadge, LemonButton } from '@posthog/lemon-ui'
+import { useActions, useValues } from 'kea'
+
+import { sidePanelStateLogic } from '~/layout/navigation-3000/sidepanel/sidePanelStateLogic'
+import { SidePanelTab } from '~/types'
+
+import { metalyticsLogic } from './metalyticsLogic'
+
+export function MetalyticsSummary(): JSX.Element | null {
+    const { instanceId, viewCount, viewCountLoading } = useValues(metalyticsLogic)
+    const safeViewCount = viewCount?.views ?? 0
+    const safeUniqueUsers = viewCount?.users ?? 0
+    const { openSidePanel } = useActions(sidePanelStateLogic)
+
+    if (!instanceId || viewCountLoading) {
+        return null
+    }
+
+    return (
+        <span className="relative inline-flex">
+            <LemonButton
+                loading={viewCountLoading}
+                icon={<IconPulse />}
+                size="small"
+                onClick={() => openSidePanel(SidePanelTab.Activity, 'metalytics')}
+                tooltip={`${safeUniqueUsers} PostHog members have viewed this a total of ${safeViewCount} times. Click to see more.`}
+            />
+            <LemonBadge.Number
+                count={safeViewCount}
+                size="small"
+                position="top-right"
+                showZero={false}
+                status="primary"
+                maxDigits={3}
+            />
+        </span>
+    )
+}
diff --git a/frontend/src/lib/components/Metalytics/metalyticsLogic.ts b/frontend/src/lib/components/Metalytics/metalyticsLogic.ts
new file mode 100644
index 0000000000000..8ddc838701121
--- /dev/null
+++ b/frontend/src/lib/components/Metalytics/metalyticsLogic.ts
@@ -0,0 +1,97 @@
+import { connect, kea, path, selectors } from 'kea'
+import { loaders } from 'kea-loaders'
+import { subscriptions } from 'kea-subscriptions'
+import api from 'lib/api'
+import { membersLogic } from 'scenes/organization/membersLogic'
+
+import { activityForSceneLogic } from '~/layout/navigation-3000/sidepanel/panels/activity/activityForSceneLogic'
+import { HogQLQuery, NodeKind } from '~/queries/schema'
+import { hogql } from '~/queries/utils'
+
+import type { metalyticsLogicType } from './metalyticsLogicType'
+
+export const metalyticsLogic = kea<metalyticsLogicType>([
+    path(['lib', 'components', 'metalytics', 'metalyticsLogic']),
+    connect({
+        values: [activityForSceneLogic, ['sceneActivityFilters'], membersLogic, ['members']],
+    }),
+
+    loaders(({ values }) => ({
+        viewCount: [
+            null as { views: number; users: number } | null,
+            {
+                loadViewCount: async () => {
+                    const query: HogQLQuery = {
+                        kind: NodeKind.HogQLQuery,
+                        query: hogql`SELECT SUM(count) AS count, COUNT(DISTINCT app_source_id) AS unique_users
+                            FROM app_metrics
+                            WHERE app_source = 'metalytics'
+                            AND instance_id = ${values.instanceId}`,
+                    }
+
+                    // NOTE: I think this gets cached heavily - how to correctly invalidate?
+                    const response = await api.query(query, undefined, undefined, true)
+                    const result = response.results as number[][]
+                    return {
+                        views: result[0][0],
+                        users: result[0][1],
+                    }
+                },
+            },
+        ],
+        recentUsers: [
+            [] as string[],
+            {
+                loadUsersLast30days: async () => {
+                    const query: HogQLQuery = {
+                        kind: NodeKind.HogQLQuery,
+                        query: hogql`SELECT DISTINCT app_source_id
+                            FROM app_metrics
+                            WHERE app_source = 'metalytics'
+                            AND instance_id = ${values.instanceId}
+                            AND timestamp >= NOW() - INTERVAL 30 DAY
+                            ORDER BY timestamp DESC`,
+                    }
+
+                    const response = await api.query(query, undefined, undefined, true)
+                    return response.results.map((result) => result[0]) as string[]
+                },
+            },
+        ],
+    })),
+
+    selectors({
+        instanceId: [
+            (s) => [s.sceneActivityFilters],
+            (sceneActivityFilters) =>
+                sceneActivityFilters?.item_id ? `${sceneActivityFilters.scope}:${sceneActivityFilters.item_id}` : null,
+        ],
+        scope: [(s) => [s.sceneActivityFilters], (sceneActivityFilters) => sceneActivityFilters?.scope],
+
+        recentUserMembers: [
+            (s) => [s.recentUsers, s.members],
+            (recentUsers, members) => {
+                if (!members || !recentUsers) {
+                    return []
+                }
+                // Filter members whose IDs match the recentUsers array
+                const filteredMembers = members.filter((member) => recentUsers.includes(String(member.user.id)))
+                return filteredMembers
+            },
+        ],
+    }),
+
+    subscriptions(({ actions }) => ({
+        instanceId: async (instanceId) => {
+            if (instanceId) {
+                actions.loadViewCount()
+                actions.loadUsersLast30days()
+
+                await api.create('/api/projects/@current/metalytics/', {
+                    metric_name: 'viewed',
+                    instance_id: instanceId,
+                })
+            }
+        },
+    })),
+])
diff --git a/frontend/src/lib/components/Playlist/Playlist.tsx b/frontend/src/lib/components/Playlist/Playlist.tsx
index 7e95122e77b68..41853e0600a2b 100644
--- a/frontend/src/lib/components/Playlist/Playlist.tsx
+++ b/frontend/src/lib/components/Playlist/Playlist.tsx
@@ -26,7 +26,7 @@ export type PlaylistSection<T> = {
 export type PlaylistProps<T> = {
     sections: PlaylistSection<T>[]
     listEmptyState: JSX.Element
-    content: ({ activeItem }: { activeItem: T | null }) => JSX.Element
+    content: (({ activeItem }: { activeItem: T | null }) => JSX.Element) | null
     title?: string
     notebooksHref?: string
     embedded?: boolean
@@ -149,7 +149,7 @@ export function Playlist<
                     onDoubleClick={() => setListCollapsed(!listCollapsed)}
                 />
             </div>
-            <div className="Playlist__main">{content({ activeItem })}</div>
+            {content && <div className="Playlist__main">{content({ activeItem })}</div>}
         </div>
     )
 }
diff --git a/frontend/src/lib/components/PropertiesTable/PropertiesTable.tsx b/frontend/src/lib/components/PropertiesTable/PropertiesTable.tsx
index 756844702c3e5..54389b51c0271 100644
--- a/frontend/src/lib/components/PropertiesTable/PropertiesTable.tsx
+++ b/frontend/src/lib/components/PropertiesTable/PropertiesTable.tsx
@@ -166,7 +166,7 @@ function ValueDisplay({
                             }
                         >
                             <LemonTag
-                                className="font-mono uppercase ml-1"
+                                className="ml-1 font-mono uppercase"
                                 type={isTypeMismatched ? 'danger' : 'muted'}
                                 icon={isTypeMismatched ? <IconWarning /> : undefined}
                             >
@@ -222,8 +222,8 @@ export function PropertiesTable({
     parent,
 }: PropertiesTableType): JSX.Element {
     const [searchTerm, setSearchTerm] = useState('')
-    const { hidePostHogPropertiesInTable } = useValues(userPreferencesLogic)
-    const { setHidePostHogPropertiesInTable } = useActions(userPreferencesLogic)
+    const { hidePostHogPropertiesInTable, hideNullValues } = useValues(userPreferencesLogic)
+    const { setHidePostHogPropertiesInTable, setHideNullValues } = useActions(userPreferencesLogic)
     const { isCloudOrDev } = useValues(preflightLogic)
 
     const objectProperties = useMemo(() => {
@@ -283,11 +283,18 @@ export function PropertiesTable({
             })
         }
 
-        if (filterable && hidePostHogPropertiesInTable) {
-            entries = entries.filter(([key]) => {
-                const isPostHogProperty = key.startsWith('$') || PROPERTY_KEYS.includes(key)
-                const isNonDollarPostHogProperty = isCloudOrDev && CLOUD_INTERNAL_POSTHOG_PROPERTY_KEYS.includes(key)
-                return !isPostHogProperty && !isNonDollarPostHogProperty
+        if (filterable) {
+            entries = entries.filter(([key, value]) => {
+                if (hideNullValues && value === null) {
+                    return false
+                }
+                if (hidePostHogPropertiesInTable) {
+                    const isPostHogProperty = key.startsWith('$') || PROPERTY_KEYS.includes(key)
+                    const isNonDollarPostHogProperty =
+                        isCloudOrDev && CLOUD_INTERNAL_POSTHOG_PROPERTY_KEYS.includes(key)
+                    return !isPostHogProperty && !isNonDollarPostHogProperty
+                }
+                return true
             })
         }
 
@@ -299,7 +306,7 @@ export function PropertiesTable({
             })
         }
         return entries
-    }, [properties, sortProperties, searchTerm, hidePostHogPropertiesInTable])
+    }, [properties, sortProperties, searchTerm, hidePostHogPropertiesInTable, hideNullValues])
 
     if (Array.isArray(properties)) {
         return (
@@ -424,7 +431,7 @@ export function PropertiesTable({
         return (
             <>
                 {(searchable || filterable) && (
-                    <div className="flex justify-between items-center gap-2 mb-2">
+                    <div className="flex items-center justify-between gap-2 mb-2">
                         <span className="flex justify-between gap-2">
                             {searchable && (
                                 <LemonInput
@@ -432,17 +439,26 @@ export function PropertiesTable({
                                     placeholder="Search property keys and values"
                                     value={searchTerm || ''}
                                     onChange={setSearchTerm}
-                                    className="max-w-full w-64"
+                                    className="w-64 max-w-full"
                                 />
                             )}
 
                             {filterable && (
-                                <LemonCheckbox
-                                    checked={hidePostHogPropertiesInTable}
-                                    label="Hide PostHog properties"
-                                    bordered
-                                    onChange={setHidePostHogPropertiesInTable}
-                                />
+                                <>
+                                    <LemonCheckbox
+                                        checked={hidePostHogPropertiesInTable}
+                                        label="Hide PostHog properties"
+                                        bordered
+                                        onChange={setHidePostHogPropertiesInTable}
+                                    />
+
+                                    <LemonCheckbox
+                                        checked={hideNullValues}
+                                        label="Hide null values"
+                                        bordered
+                                        onChange={setHideNullValues}
+                                    />
+                                </>
                             )}
                         </span>
 
@@ -467,6 +483,7 @@ export function PropertiesTable({
                                         onClick={() => {
                                             setSearchTerm('')
                                             setHidePostHogPropertiesInTable(false)
+                                            setHideNullValues(false)
                                         }}
                                     >
                                         Clear filters
diff --git a/frontend/src/lib/components/Support/supportLogic.ts b/frontend/src/lib/components/Support/supportLogic.ts
index a9389640cbeb6..3e0f670074598 100644
--- a/frontend/src/lib/components/Support/supportLogic.ts
+++ b/frontend/src/lib/components/Support/supportLogic.ts
@@ -46,6 +46,29 @@ function getSessionReplayLink(): string {
     return `\nSession: ${replayUrl}`
 }
 
+function getErrorTrackingLink(): string {
+    const filterGroup = encodeURIComponent(
+        JSON.stringify({
+            type: 'AND',
+            values: [
+                {
+                    type: 'AND',
+                    values: [
+                        {
+                            key: '$session_id',
+                            value: [posthog.get_session_id()],
+                            operator: 'exact',
+                            type: 'event',
+                        },
+                    ],
+                },
+            ],
+        })
+    )
+
+    return `\nExceptions: https://us.posthog.com/project/2/error_tracking?filterGroup=${filterGroup}`
+}
+
 function getDjangoAdminLink(
     user: UserType | null,
     cloudRegion: Region | null | undefined,
@@ -178,6 +201,11 @@ export const TARGET_AREA_TO_NAME = [
                 'data-attr': `support-form-target-area-web_analytics`,
                 label: 'Web Analytics',
             },
+            {
+                value: 'error_tracking',
+                'data-attr': `support-form-target-area-error_tracking`,
+                label: 'Error tracking',
+            },
         ],
     },
 ]
@@ -211,6 +239,7 @@ export type SupportTicketTargetArea =
     | 'toolbar'
     | 'surveys'
     | 'web_analytics'
+    | 'error_tracking'
 export type SupportTicketSeverityLevel = keyof typeof SEVERITY_LEVEL_TO_NAME
 export type SupportTicketKind = keyof typeof SUPPORT_KIND_TO_SUBJECT
 
@@ -446,6 +475,7 @@ export const supportLogic = kea<supportLogicType>([
                             `\nTarget area: ${target_area}` +
                             `\nReport event: http://go/ticketByUUID/${zendesk_ticket_uuid}` +
                             getSessionReplayLink() +
+                            getErrorTrackingLink() +
                             getCurrentLocationLink() +
                             getDjangoAdminLink(
                                 userLogic.values.user,
diff --git a/frontend/src/lib/components/VersionChecker/versionCheckerLogic.test.ts b/frontend/src/lib/components/VersionChecker/versionCheckerLogic.test.ts
index 103e89b2bfed9..77e7e0e9eb52e 100644
--- a/frontend/src/lib/components/VersionChecker/versionCheckerLogic.test.ts
+++ b/frontend/src/lib/components/VersionChecker/versionCheckerLogic.test.ts
@@ -73,35 +73,41 @@ describe('versionCheckerLogic', () => {
         { versionCount: 1, expectation: null },
         {
             versionCount: 11,
+            expectation: null,
+        },
+        {
+            versionCount: 51,
             expectation: {
                 latestUsedVersion: '1.0.0',
-                latestAvailableVersion: '1.0.10',
-                numVersionsBehind: 10,
-                level: 'info',
+                latestAvailableVersion: '1.0.50',
+                numVersionsBehind: 50,
+                level: 'error',
             },
         },
         {
-            versionCount: 15,
+            minorUsedVersion: 40,
+            versionCount: 1,
             expectation: {
                 latestUsedVersion: '1.0.0',
-                latestAvailableVersion: '1.0.14',
-                numVersionsBehind: 14,
-                level: 'info',
+                latestAvailableVersion: '1.40.0',
+                numVersionsBehind: 40,
+                level: 'warning',
             },
         },
         {
-            versionCount: 25,
+            majorUsedVersion: 2,
+            versionCount: 1,
             expectation: {
                 latestUsedVersion: '1.0.0',
-                latestAvailableVersion: '1.0.24',
-                numVersionsBehind: 24,
-                level: 'error',
+                latestAvailableVersion: '2.0.0',
+                numVersionsBehind: 1,
+                level: 'info',
             },
         },
     ])('return a version warning if diff is great enough', async (options) => {
         // TODO: How do we clear the persisted value?
         const versionsList = Array.from({ length: options.versionCount }, (_, i) => ({
-            version: `1.0.${i}`,
+            version: `${options.majorUsedVersion || 1}.${options.minorUsedVersion || 0}.${i}`,
         })).reverse()
 
         useMockedVersions(
@@ -143,13 +149,14 @@ describe('versionCheckerLogic', () => {
         },
         {
             usedVersions: [
-                { version: '1.80.0', timestamp: '2023-01-01T12:00:00Z' },
-                { version: '1.83.1-beta', timestamp: '2023-01-01T10:00:00Z' },
-                { version: '1.84.0-delta', timestamp: '2023-01-01T08:00:00Z' },
+                { version: '1.40.0', timestamp: '2023-01-01T12:00:00Z' },
+                { version: '1.41.1-beta', timestamp: '2023-01-01T10:00:00Z' },
+                { version: '1.42.0', timestamp: '2023-01-01T08:00:00Z' },
+                { version: '1.42.0-delta', timestamp: '2023-01-01T08:00:00Z' },
             ],
             expectation: {
-                latestUsedVersion: '1.84.0-delta',
-                numVersionsBehind: 1,
+                latestUsedVersion: '1.42.0',
+                numVersionsBehind: 42,
                 latestAvailableVersion: '1.84.0',
                 level: 'warning',
             },
diff --git a/frontend/src/lib/components/VersionChecker/versionCheckerLogic.ts b/frontend/src/lib/components/VersionChecker/versionCheckerLogic.ts
index 7ffecbbf89c82..4c6067adf4afc 100644
--- a/frontend/src/lib/components/VersionChecker/versionCheckerLogic.ts
+++ b/frontend/src/lib/components/VersionChecker/versionCheckerLogic.ts
@@ -174,6 +174,7 @@ export const versionCheckerLogic = kea<versionCheckerLogicType>([
 
             if (!warning && sdkVersions && latestAvailableVersion) {
                 const diff = diffVersions(latestAvailableVersion, latestUsedVersion)
+
                 if (diff && diff.diff > 0) {
                     // there's a difference between the latest used version and the latest available version
 
@@ -188,18 +189,14 @@ export const versionCheckerLogic = kea<versionCheckerLogicType>([
                     }
 
                     let level: 'warning' | 'info' | 'error' | undefined
-                    if (diff.kind === 'major' || numVersionsBehind >= 20) {
+                    if (diff.kind === 'major') {
+                        level = 'info' // it is desirable to be on the latest major version, but not critical
+                    } else if (diff.kind === 'minor') {
+                        level = numVersionsBehind >= 40 ? 'warning' : undefined
+                    }
+
+                    if (level === undefined && numVersionsBehind >= 50) {
                         level = 'error'
-                    } else if (diff.kind === 'minor' && diff.diff >= 15) {
-                        level = 'warning'
-                    } else if ((diff.kind === 'minor' && diff.diff >= 10) || numVersionsBehind >= 10) {
-                        level = 'info'
-                    } else if (latestUsedVersion.extra) {
-                        // if we have an extra (alpha/beta/rc/etc.) version, we should always show a warning if they aren't on the latest
-                        level = 'warning'
-                    } else {
-                        // don't warn for a small number of patch versions behind
-                        level = undefined
                     }
 
                     // we check if there is a "latest user version string" to avoid returning odd data in unexpected cases
diff --git a/frontend/src/lib/components/ViewRecordingButton.tsx b/frontend/src/lib/components/ViewRecordingButton.tsx
index 1d0c7adb1d4b0..37de0ba0eaae0 100644
--- a/frontend/src/lib/components/ViewRecordingButton.tsx
+++ b/frontend/src/lib/components/ViewRecordingButton.tsx
@@ -10,20 +10,27 @@ import { EventType } from '~/types'
 export default function ViewRecordingButton({
     sessionId,
     timestamp,
+    inModal = false,
     ...props
 }: Pick<LemonButtonProps, 'size' | 'type' | 'data-attr' | 'fullWidth' | 'className' | 'disabledReason'> & {
     sessionId: string
     timestamp?: string | Dayjs
+    // whether to open in a modal or navigate to the replay page
+    inModal?: boolean
 }): JSX.Element {
     const { openSessionPlayer } = useActions(sessionPlayerModalLogic)
 
     return (
         <LemonButton
-            to={urls.replaySingle(sessionId)}
-            onClick={() => {
-                const fiveSecondsBeforeEvent = dayjs(timestamp).valueOf() - 5000
-                openSessionPlayer({ id: sessionId }, Math.max(fiveSecondsBeforeEvent, 0))
-            }}
+            to={inModal ? undefined : urls.replaySingle(sessionId)}
+            onClick={
+                inModal
+                    ? () => {
+                          const fiveSecondsBeforeEvent = timestamp ? dayjs(timestamp).valueOf() - 5000 : 0
+                          openSessionPlayer({ id: sessionId }, Math.max(fiveSecondsBeforeEvent, 0))
+                      }
+                    : undefined
+            }
             sideIcon={<IconPlayCircle />}
             {...props}
         >
diff --git a/frontend/src/lib/constants.tsx b/frontend/src/lib/constants.tsx
index 623848eeba79f..d41a232518b18 100644
--- a/frontend/src/lib/constants.tsx
+++ b/frontend/src/lib/constants.tsx
@@ -165,6 +165,7 @@ export const FEATURE_FLAGS = {
     PERSON_FEED_CANVAS: 'person-feed-canvas', // owner: #project-canvas
     FEATURE_FLAG_COHORT_CREATION: 'feature-flag-cohort-creation', // owner: @neilkakkar #team-feature-success
     INSIGHT_HORIZONTAL_CONTROLS: 'insight-horizontal-controls', // owner: @benjackwhite
+    SURVEYS_ADAPTIVE_LIMITS: 'surveys-adaptive-limits', // owner: #team-feature-success
     SURVEYS_WIDGETS: 'surveys-widgets', // owner: #team-feature-success
     SURVEYS_EVENTS: 'surveys-events', // owner: #team-feature-success
     SURVEYS_ACTIONS: 'surveys-actions', // owner: #team-feature-success
@@ -197,19 +198,14 @@ export const FEATURE_FLAGS = {
     SETTINGS_BOUNCE_RATE_PAGE_VIEW_MODE: 'settings-bounce-rate-page-view-mode', // owner: @robbie-c
     ONBOARDING_DASHBOARD_TEMPLATES: 'onboarding-dashboard-templates', // owner: @raquelmsmith
     MULTIPLE_BREAKDOWNS: 'multiple-breakdowns', // owner: @skoob13 #team-product-analytics
-    WEB_ANALYTICS_LIVE_USER_COUNT: 'web-analytics-live-user-count', // owner: @robbie-c
     SETTINGS_SESSION_TABLE_VERSION: 'settings-session-table-version', // owner: @robbie-c
     INSIGHT_FUNNELS_USE_UDF: 'insight-funnels-use-udf', // owner: @aspicer #team-product-analytics
     INSIGHT_FUNNELS_USE_UDF_TRENDS: 'insight-funnels-use-udf-trends', // owner: @aspicer #team-product-analytics
     FIRST_TIME_FOR_USER_MATH: 'first-time-for-user-math', // owner: @skoob13 #team-product-analytics
     MULTITAB_EDITOR: 'multitab-editor', // owner: @EDsCODE #team-data-warehouse
-    WEB_ANALYTICS_REPLAY: 'web-analytics-replay', // owner: @robbie-c
     BATCH_EXPORTS_POSTHOG_HTTP: 'posthog-http-batch-exports',
     EXPERIMENT_MAKE_DECISION: 'experiment-make-decision', // owner: @jurajmajerik #team-feature-success
     DATA_MODELING: 'data-modeling', // owner: @EDsCODE #team-data-warehouse
-    WEB_ANALYTICS_CONVERSION_GOALS: 'web-analytics-conversion-goals', // owner: @robbie-c
-    WEB_ANALYTICS_LAST_CLICK: 'web-analytics-last-click', // owner: @robbie-c
-    WEB_ANALYTICS_LCP_SCORE: 'web-analytics-lcp-score', // owner: @robbie-c
     HEDGEHOG_SKIN_SPIDERHOG: 'hedgehog-skin-spiderhog', // owner: @benjackwhite
     INSIGHT_VARIABLES: 'insight_variables', // owner: @Gilbert09 #team-data-warehouse
     WEB_EXPERIMENTS: 'web-experiments', // owner: @team-feature-success
@@ -221,21 +217,25 @@ export const FEATURE_FLAGS = {
     EXPERIMENTS_HOGQL: 'experiments-hogql', // owner: @jurajmajerik #team-experiments
     ROLE_BASED_ACCESS_CONTROL: 'role-based-access-control', // owner: @zach
     MESSAGING: 'messaging', // owner @mariusandra #team-cdp
-    SESSION_REPLAY_URL_BLOCKLIST: 'session-replay-url-blocklist', // owner: @richard-better #team-replay
     BILLING_TRIAL_FLOW: 'billing-trial-flow', // owner: @zach
     EDIT_DWH_SOURCE_CONFIG: 'edit_dwh_source_config', // owner: @Gilbert09 #team-data-warehouse
     AI_SURVEY_RESPONSE_SUMMARY: 'ai-survey-response-summary', // owner: @pauldambra
-    CUSTOM_CHANNEL_TYPE_RULES: 'custom-channel-type-rules', // owner: @robbie-c #team-web-analytics
     SELF_SERVE_CREDIT_OVERRIDE: 'self-serve-credit-override', // owner: @zach
+    FEATURE_MANAGEMENT_UI: 'feature-management-ui', // owner: @haven #team-feature-flags
     CUSTOM_CSS_THEMES: 'custom-css-themes', // owner: @daibhin
+    METALYTICS: 'metalytics', // owner: @surbhi
     EXPERIMENTS_MULTIPLE_METRICS: 'experiments-multiple-metrics', // owner: @jurajmajerik #team-experiments
-    WEB_ANALYTICS_WARN_CUSTOM_EVENT_NO_SESSION: 'web-analytics-warn-custom-event-no-session', // owner: @robbie-c #team-web-analytics
-    TWO_FACTOR_UI: 'two-factor-ui', // owner: @zach
+    REMOTE_CONFIG: 'remote-config', // owner: @benjackwhite
     SITE_DESTINATIONS: 'site-destinations', // owner: @mariusandra #team-cdp
     SITE_APP_FUNCTIONS: 'site-app-functions', // owner: @mariusandra #team-cdp
+    HOG_TRANSFORMATIONS: 'hog-transformations', // owner: #team-cdp
     REPLAY_HOGQL_FILTERS: 'replay-hogql-filters', // owner: @pauldambra #team-replay
     REPLAY_LIST_RECORDINGS_AS_QUERY: 'replay-list-recordings-as-query', // owner: @pauldambra #team-replay
     SUPPORT_MESSAGE_OVERRIDE: 'support-message-override', // owner: @abigail
+    BILLING_SKIP_FORECASTING: 'billing-skip-forecasting', // owner: @zach
+    EXPERIMENT_STATS_V2: 'experiment-stats-v2', // owner: @danielbachhuber #team-experiments
+    WEB_ANALYTICS_PERIOD_COMPARISON: 'web-analytics-period-comparison', // owner: @rafaeelaudibert #team-web-analytics
+    WEB_ANALYTICS_CONVERSION_GOAL_FILTERS: 'web-analytics-conversion-goal-filters', // owner: @rafaeelaudibert #team-web-analytics
 } as const
 export type FeatureFlagKey = (typeof FEATURE_FLAGS)[keyof typeof FEATURE_FLAGS]
 
diff --git a/frontend/src/lib/integrations/IntegrationScopesWarning.tsx b/frontend/src/lib/integrations/IntegrationScopesWarning.tsx
new file mode 100644
index 0000000000000..c9e6c7a61d764
--- /dev/null
+++ b/frontend/src/lib/integrations/IntegrationScopesWarning.tsx
@@ -0,0 +1,65 @@
+import api from 'lib/api'
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+import { Link } from 'lib/lemon-ui/Link'
+import { useMemo } from 'react'
+
+import { HogFunctionInputSchemaType, IntegrationType } from '~/types'
+
+export function IntegrationScopesWarning({
+    integration,
+    schema,
+}: {
+    integration: IntegrationType
+    schema?: HogFunctionInputSchemaType
+}): JSX.Element {
+    const getScopes = useMemo((): string[] => {
+        const scopes: any[] = []
+        const possibleScopeLocation = [integration.config.scope, integration.config.scopes]
+
+        possibleScopeLocation.map((scope) => {
+            if (typeof scope === 'string') {
+                scopes.push(scope.split(' '))
+                scopes.push(scope.split(','))
+            }
+            if (typeof scope === 'object') {
+                scopes.push(scope)
+            }
+        })
+        return scopes
+            .filter((scope: any) => typeof scope === 'object')
+            .reduce((a, b) => (a.length > b.length ? a : b), [])
+    }, [integration.config])
+
+    const requiredScopes = schema?.requiredScopes?.split(' ') || []
+    const missingScopes = requiredScopes.filter((scope: string) => !getScopes.includes(scope))
+
+    if (missingScopes.length === 0 || getScopes.length === 0) {
+        return <></>
+    }
+    return (
+        <div className="p-2">
+            <LemonBanner
+                type="error"
+                action={{
+                    children: 'Reconnect',
+                    disableClientSideRouting: true,
+                    to: api.integrations.authorizeUrl({
+                        kind: integration.kind,
+                        next: window.location.pathname,
+                    }),
+                }}
+            >
+                <span>Required scopes are missing: [{missingScopes.join(', ')}].</span>
+                {integration.kind === 'hubspot' ? (
+                    <span>
+                        Note that some features may not be available on your current HubSpot plan. Check out{' '}
+                        <Link to="https://developers.hubspot.com/beta-docs/guides/apps/authentication/scopes">
+                            this page
+                        </Link>{' '}
+                        for more details.
+                    </span>
+                ) : null}
+            </LemonBanner>
+        </div>
+    )
+}
diff --git a/frontend/src/lib/integrations/IntegrationView.tsx b/frontend/src/lib/integrations/IntegrationView.tsx
index 31cd12e82eb40..80590299bda4d 100644
--- a/frontend/src/lib/integrations/IntegrationView.tsx
+++ b/frontend/src/lib/integrations/IntegrationView.tsx
@@ -1,15 +1,18 @@
 import { LemonBanner } from '@posthog/lemon-ui'
 import api from 'lib/api'
 import { UserActivityIndicator } from 'lib/components/UserActivityIndicator/UserActivityIndicator'
+import { IntegrationScopesWarning } from 'lib/integrations/IntegrationScopesWarning'
 
-import { IntegrationType } from '~/types'
+import { HogFunctionInputSchemaType, IntegrationType } from '~/types'
 
 export function IntegrationView({
     integration,
     suffix,
+    schema,
 }: {
     integration: IntegrationType
     suffix?: JSX.Element
+    schema?: HogFunctionInputSchemaType
 }): JSX.Element {
     const errors = (integration.errors && integration.errors?.split(',')) || []
 
@@ -36,7 +39,7 @@ export function IntegrationView({
                 {suffix}
             </div>
 
-            {errors.length > 0 && (
+            {errors.length > 0 ? (
                 <div className="p-2">
                     <LemonBanner
                         type="error"
@@ -54,6 +57,8 @@ export function IntegrationView({
                             : `There was an error with this integration: ${errors[0]}`}
                     </LemonBanner>
                 </div>
+            ) : (
+                <IntegrationScopesWarning integration={integration} schema={schema} />
             )}
         </div>
     )
diff --git a/frontend/src/lib/integrations/SlackIntegrationHelpers.tsx b/frontend/src/lib/integrations/SlackIntegrationHelpers.tsx
index 14d533bf9fca9..b5690b4c55333 100644
--- a/frontend/src/lib/integrations/SlackIntegrationHelpers.tsx
+++ b/frontend/src/lib/integrations/SlackIntegrationHelpers.tsx
@@ -1,7 +1,7 @@
 import { LemonBanner, LemonButton, LemonInputSelect, LemonInputSelectOption, Link } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { IconSlackExternal } from 'lib/lemon-ui/icons'
-import { useMemo } from 'react'
+import { useEffect, useMemo } from 'react'
 
 import { IntegrationType, SlackChannelType } from '~/types'
 
@@ -53,6 +53,12 @@ export function SlackChannelPicker({ onChange, value, integration, disabled }: S
         return value
     }, [value, slackChannels])
 
+    useEffect(() => {
+        if (!disabled) {
+            loadSlackChannels()
+        }
+    }, [loadSlackChannels, disabled])
+
     return (
         <>
             <LemonInputSelect
diff --git a/frontend/src/lib/lemon-ui/LemonBanner/LemonBanner.scss b/frontend/src/lib/lemon-ui/LemonBanner/LemonBanner.scss
index 044c356dd47bd..32bed6c3f8de4 100644
--- a/frontend/src/lib/lemon-ui/LemonBanner/LemonBanner.scss
+++ b/frontend/src/lib/lemon-ui/LemonBanner/LemonBanner.scss
@@ -5,9 +5,9 @@
     min-height: 3rem;
     padding: 0.5rem;
     font-weight: 500;
-    color: var(--primary-alt);
+    color: var(--content-primary);
     text-align: left;
-    border: solid 1px var(--border-3000);
+    border: solid 1px var(--border-tertiary);
     border-radius: var(--radius);
 
     &.LemonBanner--square {
@@ -15,22 +15,22 @@
     }
 
     &.LemonBanner--info {
-        background-color: var(--primary-alt-highlight);
+        background-color: var(--background-secondary);
     }
 
     &.LemonBanner--warning {
-        color: var(--warning-dark);
-        background-color: var(--warning-highlight);
+        color: var(--content-warning-bold);
+        background-color: var(--background-warning-subtle);
     }
 
     &.LemonBanner--error {
-        color: var(--danger);
-        background-color: var(--danger-highlight);
+        color: var(--content-danger-bold);
+        background-color: var(--background-danger-subtle);
     }
 
     &.LemonBanner--success {
-        color: var(--success);
-        background-color: var(--success-highlight);
+        color: var(--content-success-bold);
+        background-color: var(--background-success-subtle);
     }
 
     .LemonBanner__icon {
diff --git a/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.scss b/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.scss
index b97f0e30bcc3f..cf41641c4c8ea 100644
--- a/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.scss
+++ b/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.scss
@@ -1,4 +1,5 @@
 .LemonCalendar {
+    --lemon-calendar-month-height: 305px;
     --lemon-calendar-row-gap: 2px;
     --lemon-calendar-day-width: 40px;
     --lemon-calendar-today-radius: 2px;
@@ -7,6 +8,9 @@
     // Tricky: needs to match the equivalent height button from LemonButton.scss
     --lemon-calendar-time-button-height: 2.3125rem;
 
+    // Force height for month so when swtiching to longer months, the height doesn't change
+    height: var(--lemon-calendar-month-height);
+
     .LemonCalendar__month {
         width: 100%;
     }
@@ -23,6 +27,10 @@
     }
 
     .LemonCalendar__month tr {
+        &.LemonCalendar__month-header {
+            height: var(--lemon-calendar-time-button-height);
+        }
+
         .LemonButton {
             &.rounded-none {
                 border-radius: 0;
diff --git a/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.tsx b/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.tsx
index f955b57a5de06..632cc6c2af229 100644
--- a/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.tsx
+++ b/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendar.tsx
@@ -81,7 +81,7 @@ export const LemonCalendar = forwardRef(function LemonCalendar(
                 return (
                     <table className="LemonCalendar__month" key={month} data-attr="lemon-calendar-month">
                         <thead>
-                            <tr>
+                            <tr className="LemonCalendar__month-header">
                                 <th className="relative">
                                     {showLeftMonth && (
                                         <LemonButton
diff --git a/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendarSelect.stories.tsx b/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendarSelect.stories.tsx
index e343c14a9d413..a183bd8329f4b 100644
--- a/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendarSelect.stories.tsx
+++ b/frontend/src/lib/lemon-ui/LemonCalendar/LemonCalendarSelect.stories.tsx
@@ -68,3 +68,6 @@ Minute.args = { granularity: 'minute' }
 
 export const WithTimeToggle: Story = BasicTemplate.bind({})
 WithTimeToggle.args = { showTimeToggle: true }
+
+export const WithTimeToggleAndMultipleMonths: Story = BasicTemplate.bind({})
+WithTimeToggleAndMultipleMonths.args = { showTimeToggle: true, months: 3 }
diff --git a/frontend/src/lib/logic/userPreferencesLogic.ts b/frontend/src/lib/logic/userPreferencesLogic.ts
index 4bbcdd352a91c..f15d4abce5713 100644
--- a/frontend/src/lib/logic/userPreferencesLogic.ts
+++ b/frontend/src/lib/logic/userPreferencesLogic.ts
@@ -7,6 +7,7 @@ export const userPreferencesLogic = kea<userPreferencesLogicType>([
     path(['lib', 'logic', 'userPreferencesLogic']),
     actions({
         setHidePostHogPropertiesInTable: (enabled: boolean) => ({ enabled }),
+        setHideNullValues: (enabled: boolean) => ({ enabled }),
     }),
     reducers(() => ({
         hidePostHogPropertiesInTable: [
@@ -16,5 +17,6 @@ export const userPreferencesLogic = kea<userPreferencesLogicType>([
                 setHidePostHogPropertiesInTable: (_, { enabled }) => enabled,
             },
         ],
+        hideNullValues: [true, { persist: true }, { setHideNullValues: (_, { enabled }) => enabled }],
     })),
 ])
diff --git a/frontend/src/lib/monaco/CodeEditor.tsx b/frontend/src/lib/monaco/CodeEditor.tsx
index aaa5303d35451..10dabd94c1bb4 100644
--- a/frontend/src/lib/monaco/CodeEditor.tsx
+++ b/frontend/src/lib/monaco/CodeEditor.tsx
@@ -16,7 +16,7 @@ import * as monaco from 'monaco-editor'
 import { useEffect, useMemo, useRef, useState } from 'react'
 
 import { themeLogic } from '~/layout/navigation-3000/themeLogic'
-import { AnyDataNode, HogLanguage } from '~/queries/schema'
+import { AnyDataNode, HogLanguage, HogQLMetadataResponse } from '~/queries/schema'
 
 if (loader) {
     loader.config({ monaco })
@@ -32,9 +32,15 @@ export interface CodeEditorProps extends Omit<EditorProps, 'loading' | 'theme'>
     sourceQuery?: AnyDataNode
     globals?: Record<string, any>
     schema?: Record<string, any> | null
+    onMetadata?: (metadata: HogQLMetadataResponse) => void
+    onError?: (error: string | null, isValidView: boolean) => void
 }
 let codeEditorIndex = 0
 
+export function initModel(model: editor.ITextModel, builtCodeEditorLogic: BuiltLogic<codeEditorLogicType>): void {
+    ;(model as any).codeEditorLogic = builtCodeEditorLogic
+}
+
 function initEditor(
     monaco: Monaco,
     editor: importedEditor.IStandaloneCodeEditor,
@@ -44,7 +50,9 @@ function initEditor(
 ): void {
     // This gives autocomplete access to the specific editor
     const model = editor.getModel()
-    ;(model as any).codeEditorLogic = builtCodeEditorLogic
+    if (model) {
+        initModel(model, builtCodeEditorLogic)
+    }
 
     if (editorProps?.language === 'hog') {
         initHogLanguage(monaco)
@@ -112,6 +120,8 @@ export function CodeEditor({
     globals,
     sourceQuery,
     schema,
+    onError,
+    onMetadata,
     ...editorProps
 }: CodeEditorProps): JSX.Element {
     const { isDarkModeOn } = useValues(themeLogic)
@@ -130,6 +140,8 @@ export function CodeEditor({
         sourceQuery,
         monaco: monaco,
         editor: editor,
+        onError,
+        onMetadata,
     })
     useMountedLogic(builtCodeEditorLogic)
 
diff --git a/frontend/src/lib/monaco/codeEditorLogic.tsx b/frontend/src/lib/monaco/codeEditorLogic.tsx
index 05506028c1c93..42e95f25209a4 100644
--- a/frontend/src/lib/monaco/codeEditorLogic.tsx
+++ b/frontend/src/lib/monaco/codeEditorLogic.tsx
@@ -1,6 +1,7 @@
 import type { Monaco } from '@monaco-editor/react'
 import { actions, connect, kea, key, listeners, path, props, propsChanged, reducers, selectors } from 'kea'
 import { loaders } from 'kea-loaders'
+import { subscriptions } from 'kea-subscriptions'
 import { FEATURE_FLAGS } from 'lib/constants'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 // Note: we can oly import types and not values from monaco-editor, because otherwise some Monaco code breaks
@@ -48,6 +49,8 @@ export interface CodeEditorLogicProps {
     editor?: editor.IStandaloneCodeEditor | null
     globals?: Record<string, any>
     multitab?: boolean
+    onError?: (error: string | null, isValidView: boolean) => void
+    onMetadata?: (metadata: HogQLMetadataResponse) => void
 }
 
 export const codeEditorLogic = kea<codeEditorLogicType>([
@@ -98,6 +101,7 @@ export const codeEditorLogic = kea<codeEditorLogicType>([
                         variables,
                     })
                     breakpoint()
+                    props.onMetadata?.(response)
                     return [query, response]
                 },
             },
@@ -270,6 +274,14 @@ export const codeEditorLogic = kea<codeEditorLogicType>([
             },
         ],
     }),
+    subscriptions(({ props, values }) => ({
+        isValidView: (isValidView) => {
+            props.onError?.(values.error, isValidView)
+        },
+        error: (error) => {
+            props.onError?.(error, values.isValidView)
+        },
+    })),
     propsChanged(({ actions, props }, oldProps) => {
         if (
             props.query !== oldProps.query ||
diff --git a/frontend/src/lib/utils/concurrencyController.ts b/frontend/src/lib/utils/concurrencyController.ts
index 47683b954be86..941af92f33b74 100644
--- a/frontend/src/lib/utils/concurrencyController.ts
+++ b/frontend/src/lib/utils/concurrencyController.ts
@@ -1,5 +1,5 @@
+import FastPriorityQueue from 'fastpriorityqueue'
 import { promiseResolveReject } from 'lib/utils'
-
 class ConcurrencyControllerItem<T> {
     _debugTag?: string
     _runFn: () => Promise<void>
@@ -52,7 +52,9 @@ export class ConcurrencyController {
     _concurrencyLimit: number
 
     _current: ConcurrencyControllerItem<any>[] = []
-    private _queue: ConcurrencyControllerItem<any>[] = []
+    private _queue: FastPriorityQueue<ConcurrencyControllerItem<any>> = new FastPriorityQueue(
+        (a, b) => a._priority < b._priority
+    )
 
     constructor(concurrencyLimit: number) {
         this._concurrencyLimit = concurrencyLimit
@@ -79,7 +81,7 @@ export class ConcurrencyController {
     }): Promise<T> => {
         const item = new ConcurrencyControllerItem(this, fn, abortController, priority, debugTag)
 
-        this._queue.push(item)
+        this._queue.add(item)
 
         this._tryRunNext()
 
@@ -87,8 +89,7 @@ export class ConcurrencyController {
     }
 
     _runNext(): void {
-        this._queue.sort((a, b) => a._priority - b._priority)
-        const next = this._queue.shift()
+        const next = this._queue.poll()
         if (next) {
             next._runFn()
                 .catch(() => {
diff --git a/frontend/src/loadPostHogJS.tsx b/frontend/src/loadPostHogJS.tsx
index badabf1105246..4dfc4e30ee47f 100644
--- a/frontend/src/loadPostHogJS.tsx
+++ b/frontend/src/loadPostHogJS.tsx
@@ -67,6 +67,7 @@ export function loadPostHogJS(): void {
                     capture_copied_text: true,
                 },
                 person_profiles: 'always',
+                __preview_remote_config: true,
 
                 // Helper to capture events for assertions in Cypress
                 _onCapture: (window as any)._cypress_posthog_captures
diff --git a/frontend/src/mocks/handlers.ts b/frontend/src/mocks/handlers.ts
index 9d14c1b3c0acf..de9e072e7f69b 100644
--- a/frontend/src/mocks/handlers.ts
+++ b/frontend/src/mocks/handlers.ts
@@ -119,6 +119,7 @@ export const defaultMocks: Mocks = {
                 },
             },
         ],
+        '/api/users/@me/two_factor_status/': () => [200, { is_enabled: true, backup_codes: [], method: 'TOTP' }],
         '/api/environments/@current/': MOCK_DEFAULT_TEAM,
         '/api/projects/@current/': MOCK_DEFAULT_TEAM,
         '/api/projects/:team_id/comments/count': { count: 0 },
diff --git a/frontend/src/models/dashboardsModel.tsx b/frontend/src/models/dashboardsModel.tsx
index 99c4cdf01ea96..2c23d08675c2a 100644
--- a/frontend/src/models/dashboardsModel.tsx
+++ b/frontend/src/models/dashboardsModel.tsx
@@ -114,10 +114,10 @@ export const dashboardsModel = kea<dashboardsModelType>([
 
                 const beforeChange = { ...values.rawDashboards[id] }
 
-                const response = (await api.update(
+                const response = await api.update<DashboardType>(
                     `api/environments/${teamLogic.values.currentTeamId}/dashboards/${id}`,
                     payload
-                )) as DashboardType
+                )
                 const updatedAttribute = Object.keys(payload)[0]
                 if (updatedAttribute === 'name' || updatedAttribute === 'description' || updatedAttribute === 'tags') {
                     eventUsageLogic.actions.reportDashboardFrontEndUpdate(
@@ -134,10 +134,10 @@ export const dashboardsModel = kea<dashboardsModelType>([
                         button: {
                             label: 'Undo',
                             action: async () => {
-                                const reverted = (await api.update(
+                                const reverted = await api.update<DashboardType>(
                                     `api/environments/${teamLogic.values.currentTeamId}/dashboards/${id}`,
                                     beforeChange
-                                )) as DashboardType
+                                )
                                 actions.updateDashboardSuccess(getQueryBasedDashboard(reverted))
                                 lemonToast.success('Dashboard change reverted')
                             },
@@ -160,31 +160,34 @@ export const dashboardsModel = kea<dashboardsModelType>([
                     })
                 ) as DashboardType<QueryBasedInsightModel>,
             pinDashboard: async ({ id, source }) => {
-                const response = (await api.update(
+                const response = await api.update(
                     `api/environments/${teamLogic.values.currentTeamId}/dashboards/${id}`,
                     {
                         pinned: true,
                     }
-                )) as DashboardType
+                )
                 eventUsageLogic.actions.reportDashboardPinToggled(true, source)
                 return getQueryBasedDashboard(response)!
             },
             unpinDashboard: async ({ id, source }) => {
-                const response = (await api.update(
+                const response = await api.update<DashboardType>(
                     `api/environments/${teamLogic.values.currentTeamId}/dashboards/${id}`,
                     {
                         pinned: false,
                     }
-                )) as DashboardType
+                )
                 eventUsageLogic.actions.reportDashboardPinToggled(false, source)
                 return getQueryBasedDashboard(response)!
             },
             duplicateDashboard: async ({ id, name, show, duplicateTiles }) => {
-                const result = (await api.create(`api/environments/${teamLogic.values.currentTeamId}/dashboards/`, {
-                    use_dashboard: id,
-                    name: `${name} (Copy)`,
-                    duplicate_tiles: duplicateTiles,
-                })) as DashboardType
+                const result = await api.create<DashboardType>(
+                    `api/environments/${teamLogic.values.currentTeamId}/dashboards/`,
+                    {
+                        use_dashboard: id,
+                        name: `${name} (Copy)`,
+                        duplicate_tiles: duplicateTiles,
+                    }
+                )
                 if (show) {
                     router.actions.push(urls.dashboard(result.id))
                 }
diff --git a/frontend/src/queries/nodes/DataNode/dataNodeLogic.ts b/frontend/src/queries/nodes/DataNode/dataNodeLogic.ts
index b3cada69a6a89..f1bbaa4516c55 100644
--- a/frontend/src/queries/nodes/DataNode/dataNodeLogic.ts
+++ b/frontend/src/queries/nodes/DataNode/dataNodeLogic.ts
@@ -81,6 +81,8 @@ export interface DataNodeLogicProps {
     filtersOverride?: DashboardFilter | null
     /** Dashboard variables to override the ones in the query */
     variablesOverride?: Record<string, HogQLVariable> | null
+
+    autoLoad?: boolean
 }
 
 export const AUTOLOAD_INTERVAL = 30000
@@ -114,7 +116,7 @@ export const dataNodeLogic = kea<dataNodeLogicType>([
             ],
         ],
     })),
-    props({ query: {}, variablesOverride: undefined } as DataNodeLogicProps),
+    props({ query: {}, variablesOverride: undefined, autoLoad: true } as DataNodeLogicProps),
     propsChanged(({ actions, props }, oldProps) => {
         if (!props.query) {
             return // Can't do anything without a query
@@ -131,6 +133,7 @@ export const dataNodeLogic = kea<dataNodeLogicType>([
             actions.loadData(queryVarsHaveChanged, queryStatus.id)
         } else if (
             hasQueryChanged &&
+            props.autoLoad &&
             !(props.cachedResults && props.key.includes('dashboard')) && // Don't load data on dashboard if cached results are available
             (!props.cachedResults ||
                 (isInsightQueryNode(props.query) && !props.cachedResults['result'] && !props.cachedResults['results']))
@@ -188,6 +191,10 @@ export const dataNodeLogic = kea<dataNodeLogicType>([
                         if (cache.localResults[stringifiedQuery] && !refresh) {
                             return cache.localResults[stringifiedQuery]
                         }
+
+                        if (!query.query) {
+                            return null
+                        }
                     }
 
                     if (!values.currentTeamId) {
@@ -334,6 +341,12 @@ export const dataNodeLogic = kea<dataNodeLogicType>([
         ],
     })),
     reducers(({ props }) => ({
+        isRefresh: [
+            false,
+            {
+                loadData: (_, { refresh }) => !!refresh,
+            },
+        ],
         dataLoading: [
             false,
             {
@@ -471,8 +484,12 @@ export const dataNodeLogic = kea<dataNodeLogicType>([
             (variablesOverride) => !!variablesOverride,
         ],
         isShowingCachedResults: [
-            () => [(_, props) => props.cachedResults ?? null, (_, props) => props.query],
-            (cachedResults: AnyResponseType | null, query: DataNode): boolean => {
+            (s) => [(_, props) => props.cachedResults ?? null, (_, props) => props.query, s.isRefresh],
+            (cachedResults: AnyResponseType | null, query: DataNode, isRefresh): boolean => {
+                if (isRefresh) {
+                    return false
+                }
+
                 return (
                     !!cachedResults ||
                     (cache.localResults && 'query' in query && JSON.stringify(query.query) in cache.localResults)
@@ -627,23 +644,26 @@ export const dataNodeLogic = kea<dataNodeLogicType>([
             (s) => [s.nextAllowedRefresh, s.lastRefresh],
             (nextAllowedRefresh: string | null, lastRefresh: string | null) => (): string => {
                 const now = dayjs()
-                let disabledReason = ''
-                if (!!nextAllowedRefresh && now.isBefore(dayjs(nextAllowedRefresh))) {
-                    // If this is a saved insight, the result will contain nextAllowedRefresh, and we use that to disable the button
-                    disabledReason = `You can refresh this insight again ${dayjs(nextAllowedRefresh).from(now)}`
-                } else if (
-                    !!lastRefresh &&
-                    now.subtract(UNSAVED_INSIGHT_MIN_REFRESH_INTERVAL_MINUTES - 0.5, 'minutes').isBefore(lastRefresh)
-                ) {
-                    // Unsaved insights don't get cached and get refreshed on every page load, but we avoid allowing users to click
-                    // 'refresh' more than once every UNSAVED_INSIGHT_MIN_REFRESH_INTERVAL_MINUTES. This can be bypassed by simply
-                    // refreshing the page though, as there's no cache layer on the backend
-                    disabledReason = `You can refresh this insight again ${dayjs(lastRefresh)
-                        .add(UNSAVED_INSIGHT_MIN_REFRESH_INTERVAL_MINUTES, 'minutes')
-                        .from(now)}`
+                // Saved insights has a nextAllowedRefresh we use to check if the user can refresh again
+                if (nextAllowedRefresh) {
+                    const nextRefreshTime = dayjs(nextAllowedRefresh)
+                    if (now.isBefore(nextRefreshTime)) {
+                        return `You can refresh this insight again ${nextRefreshTime.from(now)}`
+                    }
                 }
-
-                return disabledReason
+                // For unsaved insights we check the last refresh time
+                if (lastRefresh) {
+                    const earliestRefresh = dayjs(lastRefresh).add(
+                        UNSAVED_INSIGHT_MIN_REFRESH_INTERVAL_MINUTES,
+                        'minutes'
+                    )
+                    if (now.isBefore(earliestRefresh)) {
+                        return `You can refresh this insight again ${earliestRefresh.from(now)}`
+                    }
+                }
+                // If we don't have a nextAllowedRefresh or lastRefresh, we can refresh, so we
+                // return an empty string
+                return ''
             },
         ],
         timings: [
diff --git a/frontend/src/queries/nodes/DataTable/EventRowActions.tsx b/frontend/src/queries/nodes/DataTable/EventRowActions.tsx
index 5a2830a135ef2..5ac043b46654f 100644
--- a/frontend/src/queries/nodes/DataTable/EventRowActions.tsx
+++ b/frontend/src/queries/nodes/DataTable/EventRowActions.tsx
@@ -55,6 +55,7 @@ export function EventRowActions({ event }: EventActionProps): JSX.Element {
                     )}
                     <ViewRecordingButton
                         fullWidth
+                        inModal
                         sessionId={event.properties.$session_id}
                         timestamp={event.timestamp}
                         disabledReason={
diff --git a/frontend/src/queries/nodes/DataVisualization/Components/Variables/variablesLogic.ts b/frontend/src/queries/nodes/DataVisualization/Components/Variables/variablesLogic.ts
index 6d2f92eead426..d66b5e87c32e1 100644
--- a/frontend/src/queries/nodes/DataVisualization/Components/Variables/variablesLogic.ts
+++ b/frontend/src/queries/nodes/DataVisualization/Components/Variables/variablesLogic.ts
@@ -1,4 +1,4 @@
-import { actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
+import { actions, afterMount, connect, kea, key, listeners, path, props, propsChanged, reducers, selectors } from 'kea'
 import { subscriptions } from 'kea-subscriptions'
 import { FEATURE_FLAGS } from 'lib/constants'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
@@ -18,6 +18,8 @@ export interface VariablesLogicProps {
     readOnly: boolean
     /** Dashboard ID for the current dashboard if we're viewing one */
     dashboardId?: DashboardType['id']
+
+    queryInput?: string
 }
 
 const convertValueToCorrectType = (value: string, type: VariableType): number | string | boolean => {
@@ -59,6 +61,11 @@ export const variablesLogic = kea<variablesLogicType>([
         setEditorQuery: (query: string) => ({ query }),
         updateSourceQuery: true,
     })),
+    propsChanged(({ props, actions }, oldProps) => {
+        if (oldProps.queryInput !== props.queryInput) {
+            actions.setEditorQuery(props.queryInput ?? '')
+        }
+    }),
     reducers({
         internalSelectedVariables: [
             [] as HogQLVariable[],
@@ -167,7 +174,6 @@ export const variablesLogic = kea<variablesLogicType>([
                     }, {} as Record<string, HogQLVariable>),
                 },
             }
-
             const queryVarsHaveChanged = haveVariablesOrFiltersChanged(query.source, values.query.source)
             if (!queryVarsHaveChanged) {
                 return
diff --git a/frontend/src/queries/nodes/DataVisualization/DataVisualization.tsx b/frontend/src/queries/nodes/DataVisualization/DataVisualization.tsx
index 61c189df39ec8..6fb22cff1ea55 100644
--- a/frontend/src/queries/nodes/DataVisualization/DataVisualization.tsx
+++ b/frontend/src/queries/nodes/DataVisualization/DataVisualization.tsx
@@ -157,7 +157,7 @@ function InternalDataTableVisualization(props: DataTableVisualizationProps): JSX
 
     const setQuerySource = useCallback(
         (source: HogQLQuery) => props.setQuery?.({ ...props.query, source }),
-        [props.setQuery]
+        [props.setQuery, props.query]
     )
 
     let component: JSX.Element | null = null
diff --git a/frontend/src/queries/nodes/DataVisualization/dataVisualizationLogic.ts b/frontend/src/queries/nodes/DataVisualization/dataVisualizationLogic.ts
index e1053f61571aa..4480fe9977755 100644
--- a/frontend/src/queries/nodes/DataVisualization/dataVisualizationLogic.ts
+++ b/frontend/src/queries/nodes/DataVisualization/dataVisualizationLogic.ts
@@ -1,7 +1,7 @@
-import { actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
+import { actions, afterMount, connect, kea, key, listeners, path, props, propsChanged, reducers, selectors } from 'kea'
 import { subscriptions } from 'kea-subscriptions'
 import { dayjs } from 'lib/dayjs'
-import { lightenDarkenColor, RGBToHex, uuid } from 'lib/utils'
+import { lightenDarkenColor, objectsEqual, RGBToHex, uuid } from 'lib/utils'
 import mergeObject from 'lodash.merge'
 import { teamLogic } from 'scenes/teamLogic'
 
@@ -242,6 +242,11 @@ export const dataVisualizationLogic = kea<dataVisualizationLogicType>([
             ['loadData'],
         ],
     })),
+    propsChanged(({ actions, props }, oldProps) => {
+        if (props.query && !objectsEqual(props.query, oldProps.query)) {
+            actions._setQuery(props.query)
+        }
+    }),
     props({ query: { source: {} } } as DataVisualizationLogicProps),
     actions(({ values }) => ({
         setVisualizationType: (visualizationType: ChartDisplayType) => ({ visualizationType }),
@@ -280,12 +285,14 @@ export const dataVisualizationLogic = kea<dataVisualizationLogicType>([
             colorMode: values.isDarkModeOn ? 'dark' : 'light',
         }),
         setConditionalFormattingRulesPanelActiveKeys: (keys: string[]) => ({ keys }),
+        _setQuery: (node: DataVisualizationNode) => ({ node }),
     })),
     reducers(({ props }) => ({
         query: [
             props.query,
             {
                 setQuery: (_, { node }) => node,
+                _setQuery: (_, { node }) => node,
             },
         ],
         visualizationType: [
@@ -583,7 +590,7 @@ export const dataVisualizationLogic = kea<dataVisualizationLogicType>([
             (state, props) => [props.key, state.dashboardId],
             (key, dashboardId) => {
                 // Key for SQL editor based visiaulizations
-                return !key.includes('SQLEditorScene') && !dashboardId
+                return !key.includes('new-SQL') && !dashboardId
             },
         ],
         sourceFeatures: [(_, props) => [props.query], (query): Set<QueryFeature> => getQueryFeatures(query.source)],
diff --git a/frontend/src/queries/nodes/EventsNode/EventPropertyFilters.tsx b/frontend/src/queries/nodes/EventsNode/EventPropertyFilters.tsx
index d8364d21c2508..d532805db83a5 100644
--- a/frontend/src/queries/nodes/EventsNode/EventPropertyFilters.tsx
+++ b/frontend/src/queries/nodes/EventsNode/EventPropertyFilters.tsx
@@ -1,7 +1,9 @@
+import { useValues } from 'kea'
 import { PropertyFilters } from 'lib/components/PropertyFilters/PropertyFilters'
 import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
 import { useState } from 'react'
 
+import { groupsModel } from '~/models/groupsModel'
 import { EventsNode, EventsQuery, HogQLQuery, SessionAttributionExplorerQuery } from '~/queries/schema'
 import { isHogQLQuery, isSessionAttributionExplorerQuery } from '~/queries/utils'
 import { AnyPropertyFilter } from '~/types'
@@ -21,6 +23,7 @@ export function EventPropertyFilters<
         isHogQLQuery(query) || isSessionAttributionExplorerQuery(query) ? query.filters?.properties : query.properties
     const eventNames =
         isHogQLQuery(query) || isSessionAttributionExplorerQuery(query) ? [] : query.event ? [query.event] : []
+    const { groupsTaxonomicTypes } = useValues(groupsModel)
 
     return !properties || Array.isArray(properties) ? (
         <PropertyFilters
@@ -30,6 +33,7 @@ export function EventPropertyFilters<
                     TaxonomicFilterGroupType.EventProperties,
                     TaxonomicFilterGroupType.PersonProperties,
                     TaxonomicFilterGroupType.EventFeatureFlags,
+                    ...groupsTaxonomicTypes,
                     TaxonomicFilterGroupType.Cohorts,
                     TaxonomicFilterGroupType.Elements,
                     TaxonomicFilterGroupType.HogQLExpression,
diff --git a/frontend/src/queries/nodes/HogQLX/render.tsx b/frontend/src/queries/nodes/HogQLX/render.tsx
index fbac43f53ce01..f07dedd62d046 100644
--- a/frontend/src/queries/nodes/HogQLX/render.tsx
+++ b/frontend/src/queries/nodes/HogQLX/render.tsx
@@ -44,6 +44,7 @@ export function renderHogQLX(value: any): JSX.Element {
             return (
                 <ErrorBoundary>
                     <ViewRecordingButton
+                        inModal
                         sessionId={sessionId}
                         type="primary"
                         size="xsmall"
diff --git a/frontend/src/queries/nodes/InsightViz/ComputationTimeWithRefresh.tsx b/frontend/src/queries/nodes/InsightViz/ComputationTimeWithRefresh.tsx
index 164525d0e3e49..ba20b2fa521bc 100644
--- a/frontend/src/queries/nodes/InsightViz/ComputationTimeWithRefresh.tsx
+++ b/frontend/src/queries/nodes/InsightViz/ComputationTimeWithRefresh.tsx
@@ -1,9 +1,11 @@
-import { Link } from '@posthog/lemon-ui'
+import { Link, Tooltip } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { dayjs } from 'lib/dayjs'
 import { usePeriodicRerender } from 'lib/hooks/usePeriodicRerender'
 import { insightDataLogic } from 'scenes/insights/insightDataLogic'
 import { insightLogic } from 'scenes/insights/insightLogic'
+import { preflightLogic } from 'scenes/PreflightCheck/preflightLogic'
+import { userLogic } from 'scenes/userLogic'
 
 import { dataNodeLogic } from '../DataNode/dataNodeLogic'
 
@@ -13,6 +15,11 @@ export function ComputationTimeWithRefresh({ disableRefresh }: { disableRefresh?
     const { insightProps } = useValues(insightLogic)
     const { getInsightRefreshButtonDisabledReason } = useValues(insightDataLogic(insightProps))
     const { loadData } = useActions(insightDataLogic(insightProps))
+    const disabledReason = getInsightRefreshButtonDisabledReason()
+
+    const { user } = useValues(userLogic)
+    const { isDev } = useValues(preflightLogic)
+    const canBypassRefreshDisabled = user?.is_staff || user?.is_impersonated || isDev
 
     usePeriodicRerender(15000) // Re-render every 15 seconds for up-to-date `insightRefreshButtonDisabledReason`
 
@@ -26,9 +33,21 @@ export function ComputationTimeWithRefresh({ disableRefresh }: { disableRefresh?
             {!disableRefresh && (
                 <>
                     <span className="px-1">•</span>
-                    <Link disabledReason={getInsightRefreshButtonDisabledReason()} onClick={() => loadData(true)}>
-                        Refresh
-                    </Link>
+                    <Tooltip
+                        title={
+                            canBypassRefreshDisabled && disabledReason
+                                ? `${disabledReason} (you can bypass this due to dev env / staff permissions)`
+                                : undefined
+                        }
+                    >
+                        <Link
+                            onClick={() => loadData(true)}
+                            className={disabledReason ? 'opacity-50' : ''}
+                            disabledReason={canBypassRefreshDisabled ? '' : disabledReason}
+                        >
+                            Refresh
+                        </Link>
+                    </Tooltip>
                 </>
             )}
         </div>
diff --git a/frontend/src/queries/nodes/InsightViz/EditorFilters.tsx b/frontend/src/queries/nodes/InsightViz/EditorFilters.tsx
index 58bcbf6154cde..90f036c734bc4 100644
--- a/frontend/src/queries/nodes/InsightViz/EditorFilters.tsx
+++ b/frontend/src/queries/nodes/InsightViz/EditorFilters.tsx
@@ -77,7 +77,7 @@ export function EditorFilters({ query, showing, embedded }: EditorFiltersProps):
         isStepsFunnel ||
         isTrendsFunnel
     const hasPathsAdvanced = hasAvailableFeature(AvailableFeature.PATHS_ADVANCED)
-    const hasAttribution = isStepsFunnel
+    const hasAttribution = isStepsFunnel || isTrendsFunnel
     const hasPathsHogQL = isPaths && pathsFilter?.includeEventTypes?.includes(PathType.HogQL)
 
     const editorFilters: InsightEditorFilterGroup[] = [
diff --git a/frontend/src/queries/nodes/InsightViz/InsightDisplayConfig.tsx b/frontend/src/queries/nodes/InsightViz/InsightDisplayConfig.tsx
index d75685def2228..ab8b30abc4f5e 100644
--- a/frontend/src/queries/nodes/InsightViz/InsightDisplayConfig.tsx
+++ b/frontend/src/queries/nodes/InsightViz/InsightDisplayConfig.tsx
@@ -34,7 +34,7 @@ import { isValidBreakdown } from '~/queries/utils'
 import { ChartDisplayType } from '~/types'
 
 export function InsightDisplayConfig(): JSX.Element {
-    const { insightProps } = useValues(insightLogic)
+    const { insightProps, canEditInsight } = useValues(insightLogic)
 
     const {
         isTrends,
@@ -54,11 +54,15 @@ export function InsightDisplayConfig(): JSX.Element {
         supportsPercentStackView,
         yAxisScaleType,
         isNonTimeSeriesDisplay,
+        compareFilter,
+        supportsCompare,
     } = useValues(insightVizDataLogic(insightProps))
     const { isTrendsFunnel, isStepsFunnel, isTimeToConvertFunnel, isEmptyFunnel } = useValues(
         funnelDataLogic(insightProps)
     )
 
+    const { updateCompareFilter } = useActions(insightVizDataLogic(insightProps))
+
     const showCompare = (isTrends && display !== ChartDisplayType.ActionsAreaGraph) || isStickiness
     const showInterval =
         isTrendsFunnel ||
@@ -161,7 +165,11 @@ export function InsightDisplayConfig(): JSX.Element {
 
                 {showCompare && (
                     <ConfigFilter>
-                        <CompareFilter />
+                        <CompareFilter
+                            compareFilter={compareFilter}
+                            updateCompareFilter={updateCompareFilter}
+                            disabled={!canEditInsight || !supportsCompare}
+                        />
                     </ConfigFilter>
                 )}
             </div>
diff --git a/frontend/src/queries/nodes/WebOverview/WebOverview.tsx b/frontend/src/queries/nodes/WebOverview/WebOverview.tsx
index 925087cd8f9dc..83af7956c55da 100644
--- a/frontend/src/queries/nodes/WebOverview/WebOverview.tsx
+++ b/frontend/src/queries/nodes/WebOverview/WebOverview.tsx
@@ -2,11 +2,9 @@ import { IconTrending } from '@posthog/icons'
 import { LemonSkeleton } from '@posthog/lemon-ui'
 import { useValues } from 'kea'
 import { getColorVar } from 'lib/colors'
-import { FEATURE_FLAGS } from 'lib/constants'
 import { IconTrendingDown, IconTrendingFlat } from 'lib/lemon-ui/icons'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
 import { Tooltip } from 'lib/lemon-ui/Tooltip'
-import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { humanFriendlyDuration, humanFriendlyLargeNumber, isNotNil, range } from 'lib/utils'
 import { useState } from 'react'
 
@@ -42,14 +40,13 @@ export function WebOverview(props: {
         onData,
         dataNodeCollectionId: dataNodeCollectionId ?? key,
     })
-    const { featureFlags } = useValues(featureFlagLogic)
     const { response, responseLoading } = useValues(logic)
 
     const webOverviewQueryResponse = response as WebOverviewQueryResponse | undefined
 
     const samplingRate = webOverviewQueryResponse?.samplingRate
 
-    const numSkeletons = props.query.conversionGoal ? 4 : featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_LCP_SCORE] ? 6 : 5
+    const numSkeletons = props.query.conversionGoal ? 4 : 6
 
     return (
         <>
diff --git a/frontend/src/queries/schema.json b/frontend/src/queries/schema.json
index 4cc9cdcdb99f1..b81e4669af38a 100644
--- a/frontend/src/queries/schema.json
+++ b/frontend/src/queries/schema.json
@@ -546,22 +546,6 @@
             },
             "type": "object"
         },
-        "AssistantCompareFilter": {
-            "additionalProperties": false,
-            "properties": {
-                "compare": {
-                    "default": false,
-                    "description": "Whether to compare the current date range to a previous date range.",
-                    "type": "boolean"
-                },
-                "compare_to": {
-                    "default": "-7d",
-                    "description": "The date range to compare to. The value is a relative date. Examples of relative dates are: `-1y` for 1 year ago, `-14m` for 14 months ago, `-100w` for 100 weeks ago, `-14d` for 14 days ago, `-30h` for 30 hours ago.",
-                    "type": "string"
-                }
-            },
-            "type": "object"
-        },
         "AssistantDateTimePropertyFilter": {
             "additionalProperties": false,
             "properties": {
@@ -585,7 +569,7 @@
             "type": "string"
         },
         "AssistantEventType": {
-            "enum": ["status", "message"],
+            "enum": ["status", "message", "conversation"],
             "type": "string"
         },
         "AssistantFunnelsBreakdownFilter": {
@@ -742,7 +726,7 @@
                     "description": "Breakdown the chart by a property"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/AssistantInsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -1043,27 +1027,11 @@
                 }
             ]
         },
-        "AssistantInsightDateRange": {
-            "additionalProperties": false,
-            "properties": {
-                "date_from": {
-                    "default": "-7d",
-                    "description": "Start date. The value can be:\n- a relative date. Examples of relative dates are: `-1y` for 1 year ago, `-14m` for 14 months ago, `-1w` for 1 week ago, `-14d` for 14 days ago, `-30h` for 30 hours ago.\n- an absolute ISO 8601 date string. a constant `yStart` for the current year start. a constant `mStart` for the current month start. a constant `dStart` for the current day start. Prefer using relative dates.",
-                    "type": ["string", "null"]
-                },
-                "date_to": {
-                    "default": null,
-                    "description": "Right boundary of the date range. Use `null` for the current date. You can not use relative dates here.",
-                    "type": ["string", "null"]
-                }
-            },
-            "type": "object"
-        },
         "AssistantInsightsQueryBase": {
             "additionalProperties": false,
             "properties": {
                 "dateRange": {
-                    "$ref": "#/definitions/AssistantInsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -1092,9 +1060,8 @@
                 "content": {
                     "type": "string"
                 },
-                "done": {
-                    "description": "We only need this \"done\" value to tell when the particular message is finished during its streaming. It won't be necessary when we optimize streaming to NOT send the entire message every time a character is added.",
-                    "type": "boolean"
+                "id": {
+                    "type": "string"
                 },
                 "type": {
                     "const": "ai",
@@ -1365,7 +1332,7 @@
                     "description": "Compare to date range"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/AssistantInsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -1469,8 +1436,25 @@
             ],
             "type": "string"
         },
+        "BaseAssistantMessage": {
+            "additionalProperties": false,
+            "properties": {
+                "id": {
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
         "BaseMathType": {
-            "enum": ["total", "dau", "weekly_active", "monthly_active", "unique_session", "first_time_for_user"],
+            "enum": [
+                "total",
+                "dau",
+                "weekly_active",
+                "monthly_active",
+                "unique_session",
+                "first_time_for_user",
+                "first_matching_event_for_user"
+            ],
             "type": "string"
         },
         "BinCountValue": {
@@ -2246,6 +2230,9 @@
                 "significant": {
                     "type": "boolean"
                 },
+                "stats_version": {
+                    "type": "integer"
+                },
                 "timezone": {
                     "type": "string"
                 },
@@ -3792,9 +3779,12 @@
             "additionalProperties": false,
             "properties": {
                 "compare": {
+                    "default": false,
+                    "description": "Whether to compare the current date range to a previous date range.",
                     "type": "boolean"
                 },
                 "compare_to": {
+                    "description": "The date range to compare to. The value is a relative date. Examples of relative dates are: `-1y` for 1 year ago, `-14m` for 14 months ago, `-100w` for 100 weeks ago, `-14d` for 14 days ago, `-30h` for 30 hours ago.",
                     "type": "string"
                 }
             },
@@ -4585,6 +4575,9 @@
                                 "significant": {
                                     "type": "boolean"
                                 },
+                                "stats_version": {
+                                    "type": "integer"
+                                },
                                 "variants": {
                                     "items": {
                                         "$ref": "#/definitions/ExperimentVariantTrendsBaseStats"
@@ -6090,6 +6083,9 @@
                 },
                 "response": {
                     "$ref": "#/definitions/ExperimentTrendsQueryResponse"
+                },
+                "stats_version": {
+                    "type": "integer"
                 }
             },
             "required": ["count_query", "kind"],
@@ -6140,6 +6136,9 @@
                 "significant": {
                     "type": "boolean"
                 },
+                "stats_version": {
+                    "type": "integer"
+                },
                 "variants": {
                     "items": {
                         "$ref": "#/definitions/ExperimentVariantTrendsBaseStats"
@@ -6200,16 +6199,15 @@
                 "content": {
                     "type": "string"
                 },
-                "done": {
-                    "const": true,
-                    "type": "boolean"
+                "id": {
+                    "type": "string"
                 },
                 "type": {
                     "const": "ai/failure",
                     "type": "string"
                 }
             },
-            "required": ["type", "done"],
+            "required": ["type"],
             "type": "object"
         },
         "FeaturePropertyFilter": {
@@ -6853,7 +6851,7 @@
                     "description": "Breakdown of the events and actions"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -7245,6 +7243,12 @@
                 "query": {
                     "type": "string"
                 },
+                "table_names": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
                 "warnings": {
                     "items": {
                         "$ref": "#/definitions/HogQLNotice"
@@ -7533,17 +7537,15 @@
                 "content": {
                     "type": "string"
                 },
-                "done": {
-                    "const": true,
-                    "description": "Human messages are only appended when done.",
-                    "type": "boolean"
+                "id": {
+                    "type": "string"
                 },
                 "type": {
                     "const": "human",
                     "type": "string"
                 }
             },
-            "required": ["type", "content", "done"],
+            "required": ["type", "content"],
             "type": "object"
         },
         "InsightActorsQuery": {
@@ -7766,24 +7768,6 @@
             },
             "type": "object"
         },
-        "InsightDateRange": {
-            "additionalProperties": false,
-            "properties": {
-                "date_from": {
-                    "default": "-7d",
-                    "type": ["string", "null"]
-                },
-                "date_to": {
-                    "type": ["string", "null"]
-                },
-                "explicitDate": {
-                    "default": false,
-                    "description": "Whether the date_from and date_to should be used verbatim. Disables rounding to the start and end of period.",
-                    "type": ["boolean", "null"]
-                }
-            },
-            "type": "object"
-        },
         "InsightFilter": {
             "anyOf": [
                 {
@@ -7946,7 +7930,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -8003,7 +7987,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -8060,7 +8044,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -8117,7 +8101,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -8174,7 +8158,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -8284,7 +8268,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -8693,7 +8677,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -9406,6 +9390,12 @@
                         "query": {
                             "type": "string"
                         },
+                        "table_names": {
+                            "items": {
+                                "type": "string"
+                            },
+                            "type": "array"
+                        },
                         "warnings": {
                             "items": {
                                 "$ref": "#/definitions/HogQLNotice"
@@ -9855,6 +9845,9 @@
                         "significant": {
                             "type": "boolean"
                         },
+                        "stats_version": {
+                            "type": "integer"
+                        },
                         "variants": {
                             "items": {
                                 "$ref": "#/definitions/ExperimentVariantTrendsBaseStats"
@@ -10483,6 +10476,9 @@
                         "significant": {
                             "type": "boolean"
                         },
+                        "stats_version": {
+                            "type": "integer"
+                        },
                         "variants": {
                             "items": {
                                 "$ref": "#/definitions/ExperimentVariantTrendsBaseStats"
@@ -11137,9 +11133,8 @@
                 "content": {
                     "type": "string"
                 },
-                "done": {
-                    "const": true,
-                    "type": "boolean"
+                "id": {
+                    "type": "string"
                 },
                 "substeps": {
                     "items": {
@@ -11152,7 +11147,7 @@
                     "type": "string"
                 }
             },
-            "required": ["type", "content", "done"],
+            "required": ["type", "content"],
             "type": "object"
         },
         "RecordingOrder": {
@@ -11455,7 +11450,7 @@
                     "description": "Groups aggregation"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -11599,17 +11594,15 @@
                 "content": {
                     "type": "string"
                 },
-                "done": {
-                    "const": true,
-                    "description": "Router messages are not streamed, so they can only be done.",
-                    "type": "boolean"
+                "id": {
+                    "type": "string"
                 },
                 "type": {
                     "const": "ai/router",
                     "type": "string"
                 }
             },
-            "required": ["type", "content", "done"],
+            "required": ["type", "content"],
             "type": "object"
         },
         "SamplingRate": {
@@ -12127,7 +12120,7 @@
                     "description": "Compare to date range"
                 },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -12666,8 +12659,19 @@
                     "$ref": "#/definitions/CompareFilter",
                     "description": "Compare to date range"
                 },
+                "conversionGoal": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/definitions/WebAnalyticsConversionGoal"
+                        },
+                        {
+                            "type": "null"
+                        }
+                    ],
+                    "description": "Whether we should be comparing against a specific conversion goal"
+                },
                 "dateRange": {
-                    "$ref": "#/definitions/InsightDateRange",
+                    "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"
                 },
                 "filterTestAccounts": {
@@ -12778,8 +12782,11 @@
                         }
                     ]
                 },
-                "done": {
-                    "type": "boolean"
+                "id": {
+                    "type": "string"
+                },
+                "initiator": {
+                    "type": "string"
                 },
                 "plan": {
                     "type": "string"
@@ -12858,6 +12865,9 @@
         "WebExternalClicksTableQuery": {
             "additionalProperties": false,
             "properties": {
+                "compareFilter": {
+                    "$ref": "#/definitions/CompareFilter"
+                },
                 "conversionGoal": {
                     "anyOf": [
                         {
@@ -12971,6 +12981,9 @@
         "WebGoalsQuery": {
             "additionalProperties": false,
             "properties": {
+                "compareFilter": {
+                    "$ref": "#/definitions/CompareFilter"
+                },
                 "conversionGoal": {
                     "anyOf": [
                         {
@@ -13110,8 +13123,8 @@
         "WebOverviewQuery": {
             "additionalProperties": false,
             "properties": {
-                "compare": {
-                    "type": "boolean"
+                "compareFilter": {
+                    "$ref": "#/definitions/CompareFilter"
                 },
                 "conversionGoal": {
                     "anyOf": [
@@ -13242,6 +13255,9 @@
                 "breakdownBy": {
                     "$ref": "#/definitions/WebStatsBreakdown"
                 },
+                "compareFilter": {
+                    "$ref": "#/definitions/CompareFilter"
+                },
                 "conversionGoal": {
                     "anyOf": [
                         {
diff --git a/frontend/src/queries/schema.ts b/frontend/src/queries/schema.ts
index 790bfd5b681c3..7375910003a3f 100644
--- a/frontend/src/queries/schema.ts
+++ b/frontend/src/queries/schema.ts
@@ -367,6 +367,7 @@ export interface HogQLMetadataResponse {
     warnings: HogQLNotice[]
     notices: HogQLNotice[]
     query_status?: never
+    table_names?: string[]
 }
 
 export type AutocompleteCompletionItemKind =
@@ -819,7 +820,7 @@ interface InsightVizNodeViewProps {
 /** Base class for insight query nodes. Should not be used directly. */
 export interface InsightsQueryBase<R extends AnalyticsQueryResponseBase<any>> extends Node<R> {
     /** Date range for the query */
-    dateRange?: InsightDateRange
+    dateRange?: DateRange
     /**
      * Exclude internal and test users by applying the respective filters
      *
@@ -910,6 +911,8 @@ export interface TrendsQuery extends InsightsQueryBase<TrendsQueryResponse> {
     breakdownFilter?: BreakdownFilter
     /** Compare to date range */
     compareFilter?: CompareFilter
+    /**  Whether we should be comparing against a specific conversion goal */
+    conversionGoal?: WebAnalyticsConversionGoal | null
 }
 
 export type AssistantArrayPropertyFilterOperator = PropertyOperator.Exact | PropertyOperator.IsNot
@@ -1002,31 +1005,11 @@ export type AssistantGroupPropertyFilter = AssistantBasePropertyFilter & {
 
 export type AssistantPropertyFilter = AssistantGenericPropertyFilter | AssistantGroupPropertyFilter
 
-export interface AssistantInsightDateRange {
-    /**
-     * Start date. The value can be:
-     * - a relative date. Examples of relative dates are: `-1y` for 1 year ago, `-14m` for 14 months ago, `-1w` for 1 week ago, `-14d` for 14 days ago, `-30h` for 30 hours ago.
-     * - an absolute ISO 8601 date string.
-     * a constant `yStart` for the current year start.
-     * a constant `mStart` for the current month start.
-     * a constant `dStart` for the current day start.
-     * Prefer using relative dates.
-     * @default -7d
-     */
-    date_from?: string | null
-
-    /**
-     * Right boundary of the date range. Use `null` for the current date. You can not use relative dates here.
-     * @default null
-     */
-    date_to?: string | null
-}
-
 export interface AssistantInsightsQueryBase {
     /**
      * Date range for the query
      */
-    dateRange?: AssistantInsightDateRange
+    dateRange?: DateRange
 
     /**
      * Exclude internal and test users by applying the respective filters
@@ -1169,7 +1152,7 @@ export interface AssistantTrendsFilter {
     yAxisScaleType?: TrendsFilterLegacy['y_axis_scale_type']
 }
 
-export interface AssistantCompareFilter {
+export interface CompareFilter {
     /**
      * Whether to compare the current date range to a previous date range.
      * @default false
@@ -1178,7 +1161,6 @@ export interface AssistantCompareFilter {
 
     /**
      * The date range to compare to. The value is a relative date. Examples of relative dates are: `-1y` for 1 year ago, `-14m` for 14 months ago, `-100w` for 100 weeks ago, `-14d` for 14 days ago, `-30h` for 30 hours ago.
-     * @default -7d
      */
     compare_to?: string
 }
@@ -1787,6 +1769,7 @@ interface WebAnalyticsQueryBase<R extends Record<string, any>> extends DataNode<
     dateRange?: DateRange
     properties: WebAnalyticsPropertyFilters
     conversionGoal?: WebAnalyticsConversionGoal | null
+    compareFilter?: CompareFilter
     sampling?: {
         enabled?: boolean
         forceSamplingRate?: SamplingRate
@@ -1798,7 +1781,6 @@ interface WebAnalyticsQueryBase<R extends Record<string, any>> extends DataNode<
 
 export interface WebOverviewQuery extends WebAnalyticsQueryBase<WebOverviewQueryResponse> {
     kind: NodeKind.WebOverviewQuery
-    compare?: boolean
     includeLCPScore?: boolean
 }
 
@@ -2004,6 +1986,7 @@ export interface ExperimentTrendsQueryResponse {
     probability: Record<string, number>
     significant: boolean
     significance_code: ExperimentSignificanceCode
+    stats_version?: integer
     p_value: number
     credible_intervals: Record<string, [number, number]>
 }
@@ -2039,6 +2022,7 @@ export interface ExperimentTrendsQuery extends DataNode<ExperimentTrendsQueryRes
     // Defaults to $feature_flag_called if not specified
     // https://github.com/PostHog/posthog/blob/master/posthog/hogql_queries/experiments/experiment_trends_query_runner.py
     exposure_query?: TrendsQuery
+    stats_version?: integer
 }
 
 /**
@@ -2316,17 +2300,6 @@ export interface DateRange {
     explicitDate?: boolean | null
 }
 
-export interface InsightDateRange {
-    /** @default -7d */
-    date_from?: string | null
-    date_to?: string | null
-    /** Whether the date_from and date_to should be used verbatim. Disables
-     * rounding to the start and end of period.
-     * @default false
-     * */
-    explicitDate?: boolean | null
-}
-
 export type MultipleBreakdownType = Extract<BreakdownType, 'person' | 'event' | 'group' | 'session' | 'hogql'>
 
 export interface Breakdown {
@@ -2353,11 +2326,6 @@ export interface BreakdownFilter {
     breakdown_hide_other_aggregation?: boolean | null // hides the "other" field for trends
 }
 
-export interface CompareFilter {
-    compare?: boolean
-    compare_to?: string
-}
-
 // TODO: Rename to `DashboardFilters` for consistency with `HogQLFilters`
 export interface DashboardFilter {
     date_from?: string | null
@@ -2484,48 +2452,41 @@ export enum AssistantMessageType {
     Router = 'ai/router',
 }
 
-export interface HumanMessage {
+export interface BaseAssistantMessage {
+    id?: string
+}
+
+export interface HumanMessage extends BaseAssistantMessage {
     type: AssistantMessageType.Human
     content: string
-    /** Human messages are only appended when done. */
-    done: true
 }
 
-export interface AssistantMessage {
+export interface AssistantMessage extends BaseAssistantMessage {
     type: AssistantMessageType.Assistant
     content: string
-    /**
-     * We only need this "done" value to tell when the particular message is finished during its streaming.
-     * It won't be necessary when we optimize streaming to NOT send the entire message every time a character is added.
-     */
-    done?: boolean
 }
 
-export interface ReasoningMessage {
+export interface ReasoningMessage extends BaseAssistantMessage {
     type: AssistantMessageType.Reasoning
     content: string
     substeps?: string[]
-    done: true
 }
 
-export interface VisualizationMessage {
+export interface VisualizationMessage extends BaseAssistantMessage {
     type: AssistantMessageType.Visualization
     plan?: string
     answer?: AssistantTrendsQuery | AssistantFunnelsQuery
-    done?: boolean
+    initiator?: string
 }
 
-export interface FailureMessage {
+export interface FailureMessage extends BaseAssistantMessage {
     type: AssistantMessageType.Failure
     content?: string
-    done: true
 }
 
-export interface RouterMessage {
+export interface RouterMessage extends BaseAssistantMessage {
     type: AssistantMessageType.Router
     content: string
-    /** Router messages are not streamed, so they can only be done. */
-    done: true
 }
 
 export type RootAssistantMessage =
@@ -2539,6 +2500,7 @@ export type RootAssistantMessage =
 export enum AssistantEventType {
     Status = 'status',
     Message = 'message',
+    Conversation = 'conversation',
 }
 
 export enum AssistantGenerationStatusType {
diff --git a/frontend/src/scenes/actions/actionLogic.ts b/frontend/src/scenes/actions/actionLogic.ts
index e3a7791b6cdc1..a3101cb8d9daf 100644
--- a/frontend/src/scenes/actions/actionLogic.ts
+++ b/frontend/src/scenes/actions/actionLogic.ts
@@ -5,7 +5,8 @@ import { DataManagementTab } from 'scenes/data-management/DataManagementScene'
 import { Scene } from 'scenes/sceneTypes'
 import { urls } from 'scenes/urls'
 
-import { ActionType, Breadcrumb, HogFunctionType } from '~/types'
+import { ActivityFilters } from '~/layout/navigation-3000/sidepanel/panels/activity/activityForSceneLogic'
+import { ActionType, ActivityScope, Breadcrumb, HogFunctionType } from '~/types'
 
 import { actionEditLogic } from './actionEditLogic'
 import type { actionLogicType } from './actionLogicType'
@@ -104,6 +105,18 @@ export const actionLogic = kea<actionLogicType>([
             (s) => [s.action],
             (action) => action?.steps?.some((step) => step.properties?.find((p) => p.type === 'cohort')) ?? false,
         ],
+
+        activityFilters: [
+            (s) => [s.action],
+            (action): ActivityFilters | null => {
+                return action?.id
+                    ? {
+                          scope: ActivityScope.ACTION,
+                          item_id: String(action.id),
+                      }
+                    : null
+            },
+        ],
     }),
     listeners(({ actions, values }) => ({
         checkIsFinished: ({ action }) => {
diff --git a/frontend/src/scenes/appScenes.ts b/frontend/src/scenes/appScenes.ts
index 5beec89927201..f6a646f64f7c4 100644
--- a/frontend/src/scenes/appScenes.ts
+++ b/frontend/src/scenes/appScenes.ts
@@ -30,6 +30,7 @@ export const appScenes: Record<Scene, () => any> = {
     [Scene.Experiments]: () => import('./experiments/Experiments'),
     [Scene.Experiment]: () => import('./experiments/Experiment'),
     [Scene.FeatureFlags]: () => import('./feature-flags/FeatureFlags'),
+    [Scene.FeatureManagement]: () => import('./feature-flags/FeatureManagement'),
     [Scene.FeatureFlag]: () => import('./feature-flags/FeatureFlag'),
     [Scene.EarlyAccessFeatures]: () => import('./early-access-features/EarlyAccessFeatures'),
     [Scene.EarlyAccessFeature]: () => import('./early-access-features/EarlyAccessFeature'),
diff --git a/frontend/src/scenes/authentication/Login2FA.tsx b/frontend/src/scenes/authentication/Login2FA.tsx
index f620856bf4541..b420c0fc79a3c 100644
--- a/frontend/src/scenes/authentication/Login2FA.tsx
+++ b/frontend/src/scenes/authentication/Login2FA.tsx
@@ -25,7 +25,7 @@ export function Login2FA(): JSX.Element {
         >
             <div className="space-y-2">
                 <h2>Two-Factor Authentication</h2>
-                <p>Enter a token from your authenticator app.</p>
+                <p>Enter a token from your authenticator app or a backup code.</p>
 
                 <Form logic={login2FALogic} formKey="twofactortoken" enableFormOnSubmit className="space-y-4">
                     {generalError && <LemonBanner type="error">{generalError.detail}</LemonBanner>}
diff --git a/frontend/src/scenes/authentication/Setup2FA.tsx b/frontend/src/scenes/authentication/TwoFactorSetup.tsx
similarity index 78%
rename from frontend/src/scenes/authentication/Setup2FA.tsx
rename to frontend/src/scenes/authentication/TwoFactorSetup.tsx
index 617cd208267cd..57c73f3a655a4 100644
--- a/frontend/src/scenes/authentication/Setup2FA.tsx
+++ b/frontend/src/scenes/authentication/TwoFactorSetup.tsx
@@ -6,17 +6,17 @@ import { Form } from 'kea-forms'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
 import { LemonField } from 'lib/lemon-ui/LemonField'
 
-import { setup2FALogic } from './setup2FALogic'
+import { twoFactorLogic } from './twoFactorLogic'
 
-export function Setup2FA({ onSuccess }: { onSuccess: () => void }): JSX.Element | null {
-    const { startSetupLoading, generalError } = useValues(setup2FALogic({ onSuccess }))
+export function TwoFactorSetup({ onSuccess }: { onSuccess: () => void }): JSX.Element | null {
+    const { startSetupLoading, generalError } = useValues(twoFactorLogic({ onSuccess }))
     if (startSetupLoading) {
         return null
     }
 
     return (
         <>
-            <Form logic={setup2FALogic} formKey="token" enableFormOnSubmit className="flex flex-col space-y-4">
+            <Form logic={twoFactorLogic} formKey="token" enableFormOnSubmit className="flex flex-col space-y-4">
                 <div className="bg-white ml-auto mr-auto mt-2">
                     <img src="/account/two_factor/qrcode/" className="Setup2FA__image" />
                 </div>
diff --git a/frontend/src/scenes/authentication/TwoFactorSetupModal.tsx b/frontend/src/scenes/authentication/TwoFactorSetupModal.tsx
new file mode 100644
index 0000000000000..ae63d8649e87d
--- /dev/null
+++ b/frontend/src/scenes/authentication/TwoFactorSetupModal.tsx
@@ -0,0 +1,38 @@
+import { useActions, useValues } from 'kea'
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+import { LemonModal } from 'lib/lemon-ui/LemonModal'
+import { membersLogic } from 'scenes/organization/membersLogic'
+import { userLogic } from 'scenes/userLogic'
+
+import { twoFactorLogic } from './twoFactorLogic'
+import { TwoFactorSetup } from './TwoFactorSetup'
+
+export function TwoFactorSetupModal(): JSX.Element {
+    const { isTwoFactorSetupModalOpen, forceOpenTwoFactorSetupModal } = useValues(twoFactorLogic)
+    const { closeTwoFactorSetupModal } = useActions(twoFactorLogic)
+
+    return (
+        <LemonModal
+            title="Set up two-factor authentication"
+            isOpen={isTwoFactorSetupModalOpen || forceOpenTwoFactorSetupModal}
+            onClose={!forceOpenTwoFactorSetupModal ? () => closeTwoFactorSetupModal() : undefined}
+            closable={!forceOpenTwoFactorSetupModal}
+        >
+            <div className="max-w-md">
+                {forceOpenTwoFactorSetupModal && (
+                    <LemonBanner className="mb-4" type="warning">
+                        Your organization requires you to set up 2FA.
+                    </LemonBanner>
+                )}
+                <p>Use an authenticator app like Google Authenticator or 1Password to scan the QR code below.</p>
+                <TwoFactorSetup
+                    onSuccess={() => {
+                        closeTwoFactorSetupModal()
+                        userLogic.actions.loadUser()
+                        membersLogic.actions.loadAllMembers()
+                    }}
+                />
+            </div>
+        </LemonModal>
+    )
+}
diff --git a/frontend/src/scenes/authentication/inviteSignupLogic.ts b/frontend/src/scenes/authentication/inviteSignupLogic.ts
index 67d66bbecf30e..2e5be913f1f92 100644
--- a/frontend/src/scenes/authentication/inviteSignupLogic.ts
+++ b/frontend/src/scenes/authentication/inviteSignupLogic.ts
@@ -81,9 +81,12 @@ export const inviteSignupLogic = kea<inviteSignupLogicType>([
     forms(({ actions, values }) => ({
         signup: {
             defaults: { role_at_organization: '' } as AcceptInvitePayloadInterface,
-            errors: ({ password, first_name }) => ({
-                password: !password ? 'Please enter your password to continue' : values.validatedPassword.feedback,
+            errors: ({ password, first_name, role_at_organization }) => ({
+                password: !password
+                    ? 'Please enter your password to continue'
+                    : values.validatedPassword.feedback || undefined,
                 first_name: !first_name ? 'Please enter your name' : undefined,
+                role_at_organization: !role_at_organization ? 'Please select your role to continue' : undefined,
             }),
             submit: async (payload, breakpoint) => {
                 breakpoint()
diff --git a/frontend/src/scenes/authentication/login2FALogic.ts b/frontend/src/scenes/authentication/login2FALogic.ts
index 6232f6225312a..179462746a3b5 100644
--- a/frontend/src/scenes/authentication/login2FALogic.ts
+++ b/frontend/src/scenes/authentication/login2FALogic.ts
@@ -45,16 +45,12 @@ export const login2FALogic = kea<login2FALogicType>([
         twofactortoken: {
             defaults: { token: '' } as TwoFactorForm,
             errors: ({ token }) => ({
-                token: !token
-                    ? 'Please enter a token to continue'
-                    : token.length !== 6 || isNaN(parseInt(token))
-                    ? 'A token must consist of 6 digits'
-                    : null,
+                token: !token ? 'Please enter a token to continue' : null,
             }),
             submit: async ({ token }, breakpoint) => {
                 breakpoint()
                 try {
-                    return await api.create('api/login/token', { token })
+                    return await api.create<any>('api/login/token', { token })
                 } catch (e) {
                     const { code, detail } = e as Record<string, any>
                     actions.setGeneralError(code, detail)
diff --git a/frontend/src/scenes/authentication/loginLogic.ts b/frontend/src/scenes/authentication/loginLogic.ts
index 19d73edc00158..6ace53926171f 100644
--- a/frontend/src/scenes/authentication/loginLogic.ts
+++ b/frontend/src/scenes/authentication/loginLogic.ts
@@ -86,7 +86,7 @@ export const loginLogic = kea<loginLogicType>([
                     }
 
                     breakpoint()
-                    const response = await api.create('api/login/precheck', { email })
+                    const response = await api.create<any>('api/login/precheck', { email })
                     return { status: 'completed', ...response }
                 },
             },
@@ -102,7 +102,7 @@ export const loginLogic = kea<loginLogicType>([
             submit: async ({ email, password }, breakpoint) => {
                 breakpoint()
                 try {
-                    return await api.create('api/login', { email, password })
+                    return await api.create<any>('api/login', { email, password })
                 } catch (e) {
                     const { code } = e as Record<string, any>
                     let { detail } = e as Record<string, any>
diff --git a/frontend/src/scenes/authentication/signup/verify-email/verifyEmailLogic.ts b/frontend/src/scenes/authentication/signup/verify-email/verifyEmailLogic.ts
index 55ef8dc85375d..b1b15274f4a44 100644
--- a/frontend/src/scenes/authentication/signup/verify-email/verifyEmailLogic.ts
+++ b/frontend/src/scenes/authentication/signup/verify-email/verifyEmailLogic.ts
@@ -31,7 +31,7 @@ export const verifyEmailLogic = kea<verifyEmailLogicType>([
             {
                 validateEmailToken: async ({ uuid, token }: { uuid: string; token: string }, breakpoint) => {
                     try {
-                        await api.create(`api/users/${uuid}/verify_email/`, { token, uuid })
+                        await api.create(`api/users/verify_email/`, { token, uuid })
                         actions.setView('success')
                         await breakpoint(2000)
                         window.location.href = '/'
@@ -48,7 +48,7 @@ export const verifyEmailLogic = kea<verifyEmailLogicType>([
             {
                 requestVerificationLink: async ({ uuid }: { uuid: string }) => {
                     try {
-                        await api.create(`api/users/${uuid}/request_email_verification/`, { uuid })
+                        await api.create(`api/users/request_email_verification/`, { uuid })
                         lemonToast.success(
                             'A new verification link has been sent to the associated email address. Please check your inbox.'
                         )
diff --git a/frontend/src/scenes/authentication/setup2FALogic.ts b/frontend/src/scenes/authentication/twoFactorLogic.ts
similarity index 58%
rename from frontend/src/scenes/authentication/setup2FALogic.ts
rename to frontend/src/scenes/authentication/twoFactorLogic.ts
index 7ea0f4a498510..37c331b809868 100644
--- a/frontend/src/scenes/authentication/setup2FALogic.ts
+++ b/frontend/src/scenes/authentication/twoFactorLogic.ts
@@ -4,9 +4,11 @@ import { forms } from 'kea-forms'
 import { loaders } from 'kea-loaders'
 import api from 'lib/api'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { membersLogic } from 'scenes/organization/membersLogic'
 import { preflightLogic } from 'scenes/PreflightCheck/preflightLogic'
+import { userLogic } from 'scenes/userLogic'
 
-import type { setup2FALogicType } from './setup2FALogicType'
+import type { twoFactorLogicType } from './twoFactorLogicType'
 
 export interface TwoFactorForm {
     token: number | null
@@ -18,24 +20,55 @@ export interface TwoFactorStatus {
     method: string | null
 }
 
-export interface Setup2FALogicProps {
+export interface TwoFactorLogicProps {
     onSuccess?: () => void
 }
 
-export const setup2FALogic = kea<setup2FALogicType>([
+export const twoFactorLogic = kea<twoFactorLogicType>([
     path(['scenes', 'authentication', 'loginLogic']),
-    props({} as Setup2FALogicProps),
+    props({} as TwoFactorLogicProps),
     connect({
-        values: [preflightLogic, ['preflight'], featureFlagLogic, ['featureFlags']],
+        values: [preflightLogic, ['preflight'], featureFlagLogic, ['featureFlags'], userLogic, ['user']],
+        actions: [userLogic, ['loadUser'], membersLogic, ['loadAllMembers']],
     }),
     actions({
         setGeneralError: (code: string, detail: string) => ({ code, detail }),
         clearGeneralError: true,
-        setup: true,
         loadStatus: true,
         generateBackupCodes: true,
+        disable2FA: true,
+        openTwoFactorSetupModal: (forceOpen?: boolean) => ({ forceOpen }),
+        closeTwoFactorSetupModal: true,
+        toggleDisable2FAModal: (open: boolean) => ({ open }),
+        toggleBackupCodesModal: (open: boolean) => ({ open }),
     }),
     reducers({
+        isTwoFactorSetupModalOpen: [
+            false,
+            {
+                openTwoFactorSetupModal: () => true,
+                closeTwoFactorSetupModal: () => false,
+            },
+        ],
+        forceOpenTwoFactorSetupModal: [
+            false,
+            {
+                openTwoFactorSetupModal: (_, { forceOpen }) => !!forceOpen,
+                closeTwoFactorSetupModal: () => false,
+            },
+        ],
+        isDisable2FAModalOpen: [
+            false,
+            {
+                toggleDisable2FAModal: (_, { open }) => open,
+            },
+        ],
+        isBackupCodesModalOpen: [
+            false,
+            {
+                toggleBackupCodesModal: (_, { open }) => open,
+            },
+        ],
         generalError: [
             null as { code: string; detail: string } | null,
             {
@@ -67,9 +100,9 @@ export const setup2FALogic = kea<setup2FALogicType>([
         startSetup: [
             {},
             {
-                setup: async (_, breakpoint) => {
+                openTwoFactorSetupModal: async (_, breakpoint) => {
                     breakpoint()
-                    await api.get('api/users/@me/start_2fa_setup/')
+                    await api.get('api/users/@me/two_factor_start_setup/')
                     return { status: 'completed' }
                 },
             },
@@ -86,21 +119,7 @@ export const setup2FALogic = kea<setup2FALogicType>([
             null as { backup_codes: string[] } | null,
             {
                 generateBackupCodes: async () => {
-                    return await api.create('api/users/@me/two_factor_backup_codes/')
-                },
-            },
-        ],
-        disable2FA: [
-            false,
-            {
-                disable2FA: async () => {
-                    try {
-                        await api.create('api/users/@me/two_factor_disable/')
-                        return true
-                    } catch (e) {
-                        const { code, detail } = e as Record<string, any>
-                        throw { code, detail }
-                    }
+                    return await api.create<any>('api/users/@me/two_factor_backup_codes/')
                 },
             },
         ],
@@ -114,7 +133,7 @@ export const setup2FALogic = kea<setup2FALogicType>([
             submit: async ({ token }, breakpoint) => {
                 breakpoint()
                 try {
-                    return await api.create('api/users/@me/validate_2fa/', { token })
+                    return await api.create<any>('api/users/@me/two_factor_validate/', { token })
                 } catch (e) {
                     const { code, detail } = e as Record<string, any>
                     actions.setGeneralError(code, detail)
@@ -129,16 +148,35 @@ export const setup2FALogic = kea<setup2FALogicType>([
             actions.loadStatus()
             props.onSuccess?.()
         },
-        disable2FASuccess: () => {
-            lemonToast.success('2FA disabled successfully')
+        disable2FA: async () => {
+            try {
+                await api.create<any>('api/users/@me/two_factor_disable/')
+                lemonToast.success('2FA disabled successfully')
+                actions.loadStatus()
+
+                // Refresh user and members
+                actions.loadUser()
+                actions.loadAllMembers()
+            } catch (e) {
+                const { code, detail } = e as Record<string, any>
+                actions.setGeneralError(code, detail)
+                throw e
+            }
         },
         generateBackupCodesSuccess: () => {
             lemonToast.success('Backup codes generated successfully')
         },
+        closeTwoFactorSetupModal: () => {
+            // Clear the form when closing the modal
+            actions.resetToken()
+        },
     })),
 
-    afterMount(({ actions }) => {
-        actions.setup()
+    afterMount(({ actions, values }) => {
         actions.loadStatus()
+
+        if (values.user && values.user.organization?.enforce_2fa && !values.user.is_2fa_enabled) {
+            actions.openTwoFactorSetupModal(true)
+        }
     }),
 ])
diff --git a/frontend/src/scenes/billing/billingLogic.tsx b/frontend/src/scenes/billing/billingLogic.tsx
index ac78f13424b72..d6f0fa86493a1 100644
--- a/frontend/src/scenes/billing/billingLogic.tsx
+++ b/frontend/src/scenes/billing/billingLogic.tsx
@@ -4,6 +4,7 @@ import { FieldNamePath, forms } from 'kea-forms'
 import { loaders } from 'kea-loaders'
 import { router, urlToAction } from 'kea-router'
 import api, { getJSONOrNull } from 'lib/api'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { dayjs } from 'lib/dayjs'
 import { LemonBannerAction } from 'lib/lemon-ui/LemonBanner/LemonBanner'
 import { lemonBannerLogic } from 'lib/lemon-ui/LemonBanner/lemonBannerLogic'
@@ -211,7 +212,13 @@ export const billingLogic = kea<billingLogicType>([
             null as BillingType | null,
             {
                 loadBilling: async () => {
-                    const response = await api.get('api/billing')
+                    // Note: this is a temporary flag to skip forecasting in the billing page
+                    // for customers running into performance issues until we have a more permanent fix
+                    // of splitting the billing and forecasting data.
+                    const skipForecasting = values.featureFlags[FEATURE_FLAGS.BILLING_SKIP_FORECASTING]
+                    const response = await api.get(
+                        'api/billing' + (skipForecasting ? '?include_forecasting=false' : '')
+                    )
 
                     return parseBillingResponse(response)
                 },
diff --git a/frontend/src/scenes/dashboard/newDashboardLogic.test.tsx b/frontend/src/scenes/dashboard/newDashboardLogic.test.tsx
index 03757f853741f..e694c94ea1ad0 100644
--- a/frontend/src/scenes/dashboard/newDashboardLogic.test.tsx
+++ b/frontend/src/scenes/dashboard/newDashboardLogic.test.tsx
@@ -1,36 +1,46 @@
+import { NodeKind } from '~/queries/schema'
+
 import { applyTemplate } from './newDashboardLogic'
 
 describe('template function in newDashboardLogic', () => {
     it('ignores unused variables', () => {
         expect(
-            applyTemplate({ a: 'hello', b: 'hi' }, [
-                {
-                    id: 'VARIABLE_1',
-                    name: 'a',
-                    default: {
-                        event: '$pageview',
+            applyTemplate(
+                { a: 'hello', b: 'hi' },
+                [
+                    {
+                        id: 'VARIABLE_1',
+                        name: 'a',
+                        default: {
+                            event: '$pageview',
+                        },
+                        description: 'The description of the variable',
+                        required: true,
+                        type: 'event',
                     },
-                    description: 'The description of the variable',
-                    required: true,
-                    type: 'event',
-                },
-            ])
+                ],
+                null
+            )
         ).toEqual({ a: 'hello', b: 'hi' })
     })
     it('uses identified variables', () => {
         expect(
-            applyTemplate({ a: '{VARIABLE_1}', b: 'hi' }, [
-                {
-                    id: 'VARIABLE_1',
-                    name: 'a',
-                    default: {
-                        event: '$pageview',
+            applyTemplate(
+                { a: '{VARIABLE_1}', b: 'hi' },
+                [
+                    {
+                        id: 'VARIABLE_1',
+                        name: 'a',
+                        default: {
+                            event: '$pageview',
+                        },
+                        description: 'The description of the variable',
+                        required: true,
+                        type: 'event',
                     },
-                    description: 'The description of the variable',
-                    required: true,
-                    type: 'event',
-                },
-            ])
+                ],
+                null
+            )
         ).toEqual({
             a: {
                 event: '$pageview',
@@ -38,4 +48,85 @@ describe('template function in newDashboardLogic', () => {
             b: 'hi',
         })
     })
+
+    it('replaces variables in query based tiles', () => {
+        expect(
+            applyTemplate(
+                { a: '{VARIABLE_1}' },
+                [
+                    {
+                        id: 'VARIABLE_1',
+                        name: 'a',
+                        default: {
+                            id: '$pageview',
+                        },
+                        description: 'The description of the variable',
+                        required: true,
+                        type: 'event',
+                    },
+                ],
+                NodeKind.TrendsQuery
+            )
+        ).toEqual({
+            a: {
+                event: '$pageview',
+                kind: 'EventsNode',
+                math: 'total',
+            },
+        })
+    })
+
+    it("removes the math property from query based tiles that don't support it", () => {
+        expect(
+            applyTemplate(
+                { a: '{VARIABLE_1}' },
+                [
+                    {
+                        id: 'VARIABLE_1',
+                        name: 'a',
+                        default: {
+                            id: '$pageview',
+                        },
+                        description: 'The description of the variable',
+                        required: true,
+                        type: 'event',
+                    },
+                ],
+                NodeKind.LifecycleQuery
+            )
+        ).toEqual({
+            a: {
+                event: '$pageview',
+                kind: 'EventsNode',
+            },
+        })
+    })
+
+    it('removes the math property from retention insight tiles', () => {
+        expect(
+            applyTemplate(
+                { a: '{VARIABLE_1}' },
+                [
+                    {
+                        id: 'VARIABLE_1',
+                        name: 'a',
+                        default: {
+                            id: '$pageview',
+                            math: 'dau' as any,
+                            type: 'events' as any,
+                        },
+                        description: 'The description of the variable',
+                        required: true,
+                        type: 'event',
+                    },
+                ],
+                NodeKind.RetentionQuery
+            )
+        ).toEqual({
+            a: {
+                id: '$pageview',
+                type: 'events',
+            },
+        })
+    })
 })
diff --git a/frontend/src/scenes/dashboard/newDashboardLogic.ts b/frontend/src/scenes/dashboard/newDashboardLogic.ts
index 6749067872258..564a24f736c1f 100644
--- a/frontend/src/scenes/dashboard/newDashboardLogic.ts
+++ b/frontend/src/scenes/dashboard/newDashboardLogic.ts
@@ -5,11 +5,15 @@ import api from 'lib/api'
 import { DashboardRestrictionLevel } from 'lib/constants'
 import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { MathAvailability } from 'scenes/insights/filters/ActionFilter/ActionFilterRow/ActionFilterRow'
 import { teamLogic } from 'scenes/teamLogic'
 import { urls } from 'scenes/urls'
 
 import { dashboardsModel } from '~/models/dashboardsModel'
+import { legacyEntityToNode, sanitizeRetentionEntity } from '~/queries/nodes/InsightQuery/utils/filtersToQueryNode'
 import { getQueryBasedDashboard } from '~/queries/nodes/InsightViz/utils'
+import { NodeKind } from '~/queries/schema'
+import { isInsightVizNode } from '~/queries/utils'
 import { DashboardTemplateType, DashboardTemplateVariableType, DashboardTile, DashboardType, JsonType } from '~/types'
 
 import type { newDashboardLogicType } from './newDashboardLogicType'
@@ -35,24 +39,47 @@ export interface NewDashboardLogicProps {
 }
 
 // Currently this is a very generic recursive function incase we want to add template variables to aspects beyond events
-export function applyTemplate(obj: DashboardTile | JsonType, variables: DashboardTemplateVariableType[]): JsonType {
+export function applyTemplate(
+    obj: DashboardTile | JsonType,
+    variables: DashboardTemplateVariableType[],
+    queryKind: NodeKind | null
+): JsonType {
     if (typeof obj === 'string') {
         if (obj.startsWith('{') && obj.endsWith('}')) {
             const variableId = obj.substring(1, obj.length - 1)
             const variable = variables.find((variable) => variable.id === variableId)
             if (variable && variable.default) {
+                // added for future compatibility - at the moment we only have event variables
+                const isEventVariable = variable.type === 'event'
+
+                if (queryKind && isEventVariable) {
+                    let mathAvailability = MathAvailability.None
+                    if (queryKind === NodeKind.TrendsQuery) {
+                        mathAvailability = MathAvailability.All
+                    } else if (queryKind === NodeKind.StickinessQuery) {
+                        mathAvailability = MathAvailability.ActorsOnly
+                    } else if (queryKind === NodeKind.FunnelsQuery) {
+                        mathAvailability = MathAvailability.FunnelsOnly
+                    }
+                    return (
+                        queryKind === NodeKind.RetentionQuery
+                            ? sanitizeRetentionEntity(variable.default as any)
+                            : legacyEntityToNode(variable.default as any, true, mathAvailability)
+                    ) as JsonType
+                }
+
                 return variable.default as JsonType
             }
             return obj
         }
     }
     if (Array.isArray(obj)) {
-        return obj.map((item) => applyTemplate(item, variables))
+        return obj.map((item) => applyTemplate(item, variables, queryKind))
     }
     if (typeof obj === 'object' && obj !== null) {
         const newObject: JsonType = {}
         for (const [key, value] of Object.entries(obj)) {
-            newObject[key] = applyTemplate(value, variables)
+            newObject[key] = applyTemplate(value, variables, queryKind)
         }
         return newObject
     }
@@ -60,7 +87,15 @@ export function applyTemplate(obj: DashboardTile | JsonType, variables: Dashboar
 }
 
 function makeTilesUsingVariables(tiles: DashboardTile[], variables: DashboardTemplateVariableType[]): JsonType[] {
-    return tiles.map((tile: DashboardTile) => applyTemplate(tile, variables))
+    return tiles.map((tile: DashboardTile) => {
+        const isQueryBased = 'query' in tile && tile.query != null
+        const queryKind: NodeKind | null = isQueryBased
+            ? isInsightVizNode(tile.query as any)
+                ? (tile.query as any)?.source.kind
+                : (tile.query as any)?.kind
+            : null
+        return applyTemplate(tile, variables, queryKind)
+    })
 }
 
 export const newDashboardLogic = kea<newDashboardLogicType>([
diff --git a/frontend/src/scenes/data-warehouse/ViewLinkModal.tsx b/frontend/src/scenes/data-warehouse/ViewLinkModal.tsx
index 3004b8ee60daf..e888ee9abb21d 100644
--- a/frontend/src/scenes/data-warehouse/ViewLinkModal.tsx
+++ b/frontend/src/scenes/data-warehouse/ViewLinkModal.tsx
@@ -5,7 +5,6 @@ import {
     LemonButton,
     LemonCheckbox,
     LemonDivider,
-    LemonDropdown,
     LemonInput,
     LemonModal,
     LemonSelect,
@@ -14,12 +13,12 @@ import {
 import { useActions, useValues } from 'kea'
 import { Field, Form } from 'kea-forms'
 import { CodeSnippet, Language } from 'lib/components/CodeSnippet'
-import { HogQLEditor } from 'lib/components/HogQLEditor/HogQLEditor'
+import { HogQLDropdown } from 'lib/components/HogQLDropdown/HogQLDropdown'
 import { IconSwapHoriz } from 'lib/lemon-ui/icons'
 import { useState } from 'react'
 import { viewLinkLogic } from 'scenes/data-warehouse/viewLinkLogic'
 
-import { DatabaseSchemaField, NodeKind } from '~/queries/schema'
+import { DatabaseSchemaField } from '~/queries/schema'
 
 export function ViewLinkModal(): JSX.Element {
     const { isJoinTableModalOpen } = useValues(viewLinkLogic)
@@ -122,6 +121,7 @@ export function ViewLinkForm(): JSX.Element {
                                 />
                                 {sourceIsUsingHogQLExpression && (
                                     <HogQLDropdown
+                                        className="mt-2"
                                         hogQLValue={selectedSourceKey ?? ''}
                                         onHogQLValueChange={selectSourceKey}
                                         tableName={selectedSourceTableName ?? ''}
@@ -147,6 +147,7 @@ export function ViewLinkForm(): JSX.Element {
                                 />
                                 {joiningIsUsingHogQLExpression && (
                                     <HogQLDropdown
+                                        className="mt-2"
                                         hogQLValue={selectedJoiningKey ?? ''}
                                         onHogQLValueChange={selectJoiningKey}
                                         tableName={selectedJoiningTableName ?? ''}
@@ -247,49 +248,6 @@ export function ViewLinkForm(): JSX.Element {
     )
 }
 
-const HogQLDropdown = ({
-    hogQLValue,
-    onHogQLValueChange,
-    tableName,
-}: {
-    hogQLValue: string
-    tableName: string
-    onHogQLValueChange: (hogQLValue: string) => void
-}): JSX.Element => {
-    const [isHogQLDropdownVisible, setIsHogQLDropdownVisible] = useState(false)
-
-    return (
-        <div className="flex-auto overflow-hidden mt-2">
-            <LemonDropdown
-                visible={isHogQLDropdownVisible}
-                closeOnClickInside={false}
-                onClickOutside={() => setIsHogQLDropdownVisible(false)}
-                overlay={
-                    // eslint-disable-next-line react/forbid-dom-props
-                    <div className="w-120" style={{ maxWidth: 'max(60vw, 20rem)' }}>
-                        <HogQLEditor
-                            value={hogQLValue}
-                            metadataSource={{ kind: NodeKind.HogQLQuery, query: `SELECT * FROM ${tableName}` }}
-                            onChange={(currentValue) => {
-                                onHogQLValueChange(currentValue)
-                                setIsHogQLDropdownVisible(false)
-                            }}
-                        />
-                    </div>
-                }
-            >
-                <LemonButton
-                    fullWidth
-                    type="secondary"
-                    onClick={() => setIsHogQLDropdownVisible(!isHogQLDropdownVisible)}
-                >
-                    <code>{hogQLValue}</code>
-                </LemonButton>
-            </LemonDropdown>
-        </div>
-    )
-}
-
 interface KeyLabelProps {
     column: DatabaseSchemaField
 }
diff --git a/frontend/src/scenes/data-warehouse/editor/EditorScene.tsx b/frontend/src/scenes/data-warehouse/editor/EditorScene.tsx
index 3576303ebddd9..edf174a7cf216 100644
--- a/frontend/src/scenes/data-warehouse/editor/EditorScene.tsx
+++ b/frontend/src/scenes/data-warehouse/editor/EditorScene.tsx
@@ -8,6 +8,7 @@ import { useRef } from 'react'
 import { Sidebar } from '~/layout/navigation-3000/components/Sidebar'
 import { navigation3000Logic } from '~/layout/navigation-3000/navigationLogic'
 
+import { ViewLinkModal } from '../ViewLinkModal'
 import { editorSceneLogic } from './editorSceneLogic'
 import { editorSizingLogic } from './editorSizingLogic'
 import { QueryWindow } from './QueryWindow'
@@ -47,6 +48,7 @@ export function EditorScene(): JSX.Element {
                 )}
                 <QueryWindow />
             </div>
+            <ViewLinkModal />
         </BindLogic>
     )
 }
diff --git a/frontend/src/scenes/data-warehouse/editor/OutputPane.tsx b/frontend/src/scenes/data-warehouse/editor/OutputPane.tsx
index 988323bd02093..2fd8adf883adb 100644
--- a/frontend/src/scenes/data-warehouse/editor/OutputPane.tsx
+++ b/frontend/src/scenes/data-warehouse/editor/OutputPane.tsx
@@ -1,95 +1,52 @@
 import 'react-data-grid/lib/styles.css'
 
 import { IconGear } from '@posthog/icons'
-import { LemonButton, LemonTabs, Spinner } from '@posthog/lemon-ui'
+import { LemonButton, LemonTabs } from '@posthog/lemon-ui'
 import clsx from 'clsx'
-import { BindLogic, useActions, useValues } from 'kea'
-import { router } from 'kea-router'
+import { useActions, useValues } from 'kea'
 import { AnimationType } from 'lib/animations/animations'
 import { Animation } from 'lib/components/Animation/Animation'
 import { ExportButton } from 'lib/components/ExportButton/ExportButton'
 import { useMemo } from 'react'
 import DataGrid from 'react-data-grid'
-import { InsightErrorState } from 'scenes/insights/EmptyStates'
-import { insightDataLogic } from 'scenes/insights/insightDataLogic'
-import { insightLogic } from 'scenes/insights/insightLogic'
+import { InsightErrorState, StatelessInsightLoadingState } from 'scenes/insights/EmptyStates'
 import { HogQLBoldNumber } from 'scenes/insights/views/BoldNumber/BoldNumber'
 
 import { KeyboardShortcut } from '~/layout/navigation-3000/components/KeyboardShortcut'
 import { themeLogic } from '~/layout/navigation-3000/themeLogic'
-import { dataNodeLogic, DataNodeLogicProps } from '~/queries/nodes/DataNode/dataNodeLogic'
+import { dataNodeLogic } from '~/queries/nodes/DataNode/dataNodeLogic'
+import { ElapsedTime } from '~/queries/nodes/DataNode/ElapsedTime'
 import { LineGraph } from '~/queries/nodes/DataVisualization/Components/Charts/LineGraph'
 import { SideBar } from '~/queries/nodes/DataVisualization/Components/SideBar'
 import { Table } from '~/queries/nodes/DataVisualization/Components/Table'
 import { TableDisplay } from '~/queries/nodes/DataVisualization/Components/TableDisplay'
-import { variableModalLogic } from '~/queries/nodes/DataVisualization/Components/Variables/variableModalLogic'
+import { AddVariableButton } from '~/queries/nodes/DataVisualization/Components/Variables/AddVariableButton'
 import { VariablesForInsight } from '~/queries/nodes/DataVisualization/Components/Variables/Variables'
 import { variablesLogic } from '~/queries/nodes/DataVisualization/Components/Variables/variablesLogic'
 import { DataTableVisualizationProps } from '~/queries/nodes/DataVisualization/DataVisualization'
-import {
-    dataVisualizationLogic,
-    DataVisualizationLogicProps,
-} from '~/queries/nodes/DataVisualization/dataVisualizationLogic'
-import { displayLogic } from '~/queries/nodes/DataVisualization/displayLogic'
-import { DataVisualizationNode, HogQLQueryResponse, NodeKind } from '~/queries/schema'
-import { ChartDisplayType, ExporterFormat, ItemMode } from '~/types'
+import { dataVisualizationLogic } from '~/queries/nodes/DataVisualization/dataVisualizationLogic'
+import { HogQLQueryResponse } from '~/queries/schema'
+import { ChartDisplayType, ExporterFormat } from '~/types'
 
-import { DATAWAREHOUSE_EDITOR_ITEM_ID } from '../external/dataWarehouseExternalSceneLogic'
 import { dataWarehouseViewsLogic } from '../saved_queries/dataWarehouseViewsLogic'
 import { multitabEditorLogic } from './multitabEditorLogic'
 import { outputPaneLogic, OutputTab } from './outputPaneLogic'
+import { InfoTab } from './OutputPaneTabs/InfoTab'
 
-interface OutputPaneProps {
-    onSave: () => void
-    saveDisabledReason?: string
-    onQueryInputChange: () => void
-    logicKey: string
-    query: string
-}
-
-export function OutputPane({
-    onQueryInputChange,
-    onSave,
-    saveDisabledReason,
-    logicKey,
-    query,
-}: OutputPaneProps): JSX.Element {
+export function OutputPane(): JSX.Element {
     const { activeTab } = useValues(outputPaneLogic)
     const { setActiveTab } = useActions(outputPaneLogic)
+    const { variablesForInsight } = useValues(variablesLogic)
 
-    const codeEditorKey = `hogQLQueryEditor/${router.values.location.pathname}`
-
-    const { editingView, queryInput } = useValues(
-        multitabEditorLogic({
-            key: codeEditorKey,
-        })
-    )
+    const { editingView, sourceQuery, exportContext, isValidView, error, editorKey } = useValues(multitabEditorLogic)
+    const { saveAsInsight, saveAsView, setSourceQuery, runQuery } = useActions(multitabEditorLogic)
     const { isDarkModeOn } = useValues(themeLogic)
-    const { response, responseLoading } = useValues(
-        dataNodeLogic({
-            key: logicKey,
-            query: {
-                kind: NodeKind.HogQLQuery,
-                query,
-            },
-            doNotLoad: !query,
-        })
-    )
+    const { response, responseLoading, responseError, queryId, pollResponse } = useValues(dataNodeLogic)
     const { dataWarehouseSavedQueriesLoading } = useValues(dataWarehouseViewsLogic)
     const { updateDataWarehouseSavedQuery } = useActions(dataWarehouseViewsLogic)
+    const { visualizationType, queryCancelled } = useValues(dataVisualizationLogic)
 
-    const { insightProps } = useValues(
-        insightLogic({
-            dashboardItemId: DATAWAREHOUSE_EDITOR_ITEM_ID,
-            cachedInsight: null,
-            doNotLoad: true,
-        })
-    )
-    const { setQuery } = useActions(
-        insightDataLogic({
-            ...insightProps,
-        })
-    )
+    const vizKey = useMemo(() => `SQLEditorScene`, [])
 
     const columns = useMemo(() => {
         return (
@@ -114,50 +71,13 @@ export function OutputPane({
         })
     }, [response])
 
-    const Content = (): JSX.Element | null => {
-        if (activeTab === OutputTab.Results) {
-            return responseLoading ? (
-                <Spinner className="text-3xl" />
-            ) : !response ? (
-                <span className="text-muted mt-3">Query results will appear here</span>
-            ) : (
-                <div className="flex-1 absolute top-0 left-0 right-0 bottom-0">
-                    <DataGrid
-                        className={isDarkModeOn ? 'rdg-dark h-full' : 'rdg-light h-full'}
-                        columns={columns}
-                        rows={rows}
-                    />
-                </div>
-            )
-        }
-
-        if (activeTab === OutputTab.Visualization) {
-            return !response ? (
-                <div className="flex-1 absolute top-0 left-0 right-0 bottom-0 px-4 py-1 hide-scrollbar">
-                    <span className="text-muted mt-3">Query results will visualized here</span>
-                </div>
-            ) : (
-                <div className="flex-1 absolute top-0 left-0 right-0 bottom-0 px-4 py-1 hide-scrollbar">
-                    <DataTableVisualizationContent
-                        activeTab={activeTab}
-                        query={{
-                            kind: NodeKind.DataVisualizationNode,
-                            source: {
-                                kind: NodeKind.HogQLQuery,
-                                query,
-                            },
-                        }}
-                        setQuery={setQuery}
-                    />
-                </div>
-            )
-        }
-
-        return null
-    }
-
     return (
         <div className="flex flex-col w-full flex-1 bg-bg-3000">
+            {variablesForInsight.length > 0 && (
+                <div className="py-2 px-4">
+                    <VariablesForInsight />
+                </div>
+            )}
             <div className="flex flex-row justify-between align-center py-2 px-4 w-full h-[55px]">
                 <LemonTabs
                     activeKey={activeTab}
@@ -171,9 +91,35 @@ export function OutputPane({
                             key: OutputTab.Visualization,
                             label: 'Visualization',
                         },
+                        {
+                            key: OutputTab.Info,
+                            label: 'Info',
+                        },
                     ]}
                 />
                 <div className="flex gap-4">
+                    <AddVariableButton />
+
+                    {exportContext && (
+                        <ExportButton
+                            disabledReason={
+                                visualizationType != ChartDisplayType.ActionsTable &&
+                                'Only table results are exportable'
+                            }
+                            type="secondary"
+                            items={[
+                                {
+                                    export_format: ExporterFormat.CSV,
+                                    export_context: exportContext,
+                                },
+                                {
+                                    export_format: ExporterFormat.XLSX,
+                                    export_context: exportContext,
+                                },
+                            ]}
+                        />
+                    )}
+
                     {editingView ? (
                         <>
                             <LemonButton
@@ -182,10 +128,7 @@ export function OutputPane({
                                 onClick={() =>
                                     updateDataWarehouseSavedQuery({
                                         id: editingView.id,
-                                        query: {
-                                            kind: NodeKind.HogQLQuery,
-                                            query: queryInput,
-                                        },
+                                        query: sourceQuery.source,
                                         types: response?.types ?? [],
                                     })
                                 }
@@ -194,82 +137,55 @@ export function OutputPane({
                             </LemonButton>
                         </>
                     ) : (
-                        <LemonButton type="secondary" onClick={() => onSave()} disabledReason={saveDisabledReason}>
+                        <LemonButton
+                            type="secondary"
+                            onClick={() => saveAsView()}
+                            disabledReason={isValidView ? '' : 'Some fields may need an alias'}
+                        >
                             Save as view
                         </LemonButton>
                     )}
-                    <LemonButton loading={responseLoading} type="primary" onClick={() => onQueryInputChange()}>
+                    <LemonButton
+                        disabledReason={error ? error : ''}
+                        loading={responseLoading}
+                        type="primary"
+                        onClick={() => runQuery()}
+                    >
                         <span className="mr-1">Run</span>
                         <KeyboardShortcut command enter />
                     </LemonButton>
                 </div>
             </div>
-            <div className="flex flex-1 relative bg-dark justify-center items-center">
-                <Content />
+            <div className="flex flex-1 relative bg-dark">
+                <Content
+                    activeTab={activeTab}
+                    responseError={responseError}
+                    responseLoading={responseLoading}
+                    response={response}
+                    sourceQuery={sourceQuery}
+                    queryCancelled={queryCancelled}
+                    columns={columns}
+                    rows={rows}
+                    isDarkModeOn={isDarkModeOn}
+                    vizKey={vizKey}
+                    setSourceQuery={setSourceQuery}
+                    exportContext={exportContext}
+                    saveAsInsight={saveAsInsight}
+                    queryId={queryId}
+                    pollResponse={pollResponse}
+                    editorKey={editorKey}
+                />
+            </div>
+            <div className="flex justify-end pr-2 border-t">
+                <ElapsedTime />
             </div>
         </div>
     )
 }
 
-function DataTableVisualizationContent({
-    query,
-    setQuery,
-    activeTab,
-}: {
-    query: DataVisualizationNode
-    setQuery: (query: DataVisualizationNode) => void
-    activeTab: OutputTab
-}): JSX.Element {
-    const vizKey = `SQLEditorScene.${activeTab}`
-    const dataVisualizationLogicProps: DataVisualizationLogicProps = {
-        key: vizKey,
-        query,
-        dashboardId: undefined,
-        dataNodeCollectionId: vizKey,
-        insightMode: ItemMode.Edit,
-        loadPriority: undefined,
-        setQuery,
-        cachedResults: undefined,
-        variablesOverride: undefined,
-    }
-
-    const dataNodeLogicProps: DataNodeLogicProps = {
-        query: query.source,
-        key: vizKey,
-        cachedResults: undefined,
-        loadPriority: undefined,
-        dataNodeCollectionId: vizKey,
-        variablesOverride: undefined,
-    }
-
-    return (
-        <BindLogic logic={dataNodeLogic} props={dataNodeLogicProps}>
-            <BindLogic logic={dataVisualizationLogic} props={dataVisualizationLogicProps}>
-                <BindLogic logic={displayLogic} props={{ key: dataVisualizationLogicProps.key }}>
-                    <BindLogic logic={variablesLogic} props={{ key: dataVisualizationLogicProps.key, readOnly: false }}>
-                        <BindLogic logic={variableModalLogic} props={{ key: dataVisualizationLogicProps.key }}>
-                            <InternalDataTableVisualization
-                                uniqueKey={vizKey}
-                                query={query}
-                                setQuery={setQuery}
-                                context={{}}
-                                cachedResults={undefined}
-                            />
-                        </BindLogic>
-                    </BindLogic>
-                </BindLogic>
-            </BindLogic>
-        </BindLogic>
-    )
-}
-
-function InternalDataTableVisualization(props: DataTableVisualizationProps): JSX.Element {
-    const logic = insightLogic({
-        dashboardItemId: DATAWAREHOUSE_EDITOR_ITEM_ID,
-        cachedInsight: null,
-    })
-    const { saveAs } = useActions(logic)
-
+function InternalDataTableVisualization(
+    props: DataTableVisualizationProps & { onSaveInsight: () => void }
+): JSX.Element {
     const {
         query,
         visualizationType,
@@ -277,8 +193,6 @@ function InternalDataTableVisualization(props: DataTableVisualizationProps): JSX
         showResultControls,
         response,
         responseLoading,
-        responseError,
-        queryCancelled,
         isChartSettingsPanelOpen,
     } = useValues(dataVisualizationLogic)
 
@@ -322,29 +236,7 @@ function InternalDataTableVisualization(props: DataTableVisualizationProps): JSX
                             <SideBar />
                         </div>
                     )}
-                    <div className={clsx('w-full h-full flex-1 overflow-auto')}>
-                        {visualizationType !== ChartDisplayType.ActionsTable && responseError ? (
-                            <div
-                                className={clsx('rounded bg-bg-light relative flex flex-1 flex-col p-2', {
-                                    border: showEditingUI,
-                                })}
-                            >
-                                <InsightErrorState
-                                    query={props.query}
-                                    excludeDetail
-                                    title={
-                                        queryCancelled
-                                            ? 'The query was cancelled'
-                                            : response && 'error' in response
-                                            ? (response as any).error
-                                            : responseError
-                                    }
-                                />
-                            </div>
-                        ) : (
-                            component
-                        )}
-                    </div>
+                    <div className={clsx('w-full h-full flex-1 overflow-auto')}>{component}</div>
                 </div>
                 {showResultControls && (
                     <>
@@ -361,27 +253,7 @@ function InternalDataTableVisualization(props: DataTableVisualizationProps): JSX
                                         tooltip="Visualization settings"
                                     />
 
-                                    {props.exportContext && (
-                                        <ExportButton
-                                            disabledReason={
-                                                visualizationType != ChartDisplayType.ActionsTable &&
-                                                'Only table results are exportable'
-                                            }
-                                            type="secondary"
-                                            items={[
-                                                {
-                                                    export_format: ExporterFormat.CSV,
-                                                    export_context: props.exportContext,
-                                                },
-                                                {
-                                                    export_format: ExporterFormat.XLSX,
-                                                    export_context: props.exportContext,
-                                                },
-                                            ]}
-                                        />
-                                    )}
-
-                                    <LemonButton type="primary" onClick={() => saveAs(true, false)}>
+                                    <LemonButton type="primary" onClick={() => props.onSaveInsight()}>
                                         Create insight
                                     </LemonButton>
                                 </div>
@@ -389,9 +261,114 @@ function InternalDataTableVisualization(props: DataTableVisualizationProps): JSX
                         </div>
                     </>
                 )}
-
-                <VariablesForInsight />
             </div>
         </div>
     )
 }
+
+const ErrorState = ({ responseError, sourceQuery, queryCancelled, response }: any): JSX.Element | null => {
+    return (
+        <div className={clsx('flex-1 absolute top-0 left-0 right-0 bottom-0 overflow-scroll')}>
+            <InsightErrorState
+                query={sourceQuery}
+                excludeDetail
+                title={
+                    queryCancelled
+                        ? 'The query was cancelled'
+                        : response && 'error' in response
+                        ? response.error
+                        : responseError
+                }
+            />
+        </div>
+    )
+}
+
+const Content = ({
+    activeTab,
+    responseError,
+    responseLoading,
+    response,
+    sourceQuery,
+    queryCancelled,
+    columns,
+    rows,
+    isDarkModeOn,
+    vizKey,
+    setSourceQuery,
+    exportContext,
+    saveAsInsight,
+    queryId,
+    pollResponse,
+    editorKey,
+}: any): JSX.Element | null => {
+    if (activeTab === OutputTab.Results) {
+        if (responseError) {
+            return (
+                <ErrorState
+                    responseError={responseError}
+                    sourceQuery={sourceQuery}
+                    queryCancelled={queryCancelled}
+                    response={response}
+                />
+            )
+        }
+
+        return responseLoading ? (
+            <StatelessInsightLoadingState queryId={queryId} pollResponse={pollResponse} />
+        ) : !response ? (
+            <div className="flex flex-1 justify-center items-center">
+                <span className="text-muted mt-3">Query results will appear here</span>
+            </div>
+        ) : (
+            <div className="flex-1 absolute top-0 left-0 right-0 bottom-0">
+                <DataGrid
+                    className={isDarkModeOn ? 'rdg-dark h-full' : 'rdg-light h-full'}
+                    columns={columns}
+                    rows={rows}
+                />
+            </div>
+        )
+    }
+
+    if (activeTab === OutputTab.Visualization) {
+        if (responseError) {
+            return (
+                <ErrorState
+                    responseError={responseError}
+                    sourceQuery={sourceQuery}
+                    queryCancelled={queryCancelled}
+                    response={response}
+                />
+            )
+        }
+
+        return !response ? (
+            <div className="flex flex-1 justify-center items-center">
+                <span className="text-muted mt-3">Query results will be visualized here</span>
+            </div>
+        ) : (
+            <div className="flex-1 absolute top-0 left-0 right-0 bottom-0 px-4 py-1 hide-scrollbar">
+                <InternalDataTableVisualization
+                    uniqueKey={vizKey}
+                    query={sourceQuery}
+                    setQuery={setSourceQuery}
+                    context={{}}
+                    cachedResults={undefined}
+                    exportContext={exportContext}
+                    onSaveInsight={saveAsInsight}
+                />
+            </div>
+        )
+    }
+
+    if (activeTab === OutputTab.Info) {
+        return (
+            <div className="flex flex-1 relative bg-dark">
+                <InfoTab codeEditorKey={editorKey} />
+            </div>
+        )
+    }
+
+    return null
+}
diff --git a/frontend/src/scenes/data-warehouse/editor/OutputPaneTabs/InfoTab.tsx b/frontend/src/scenes/data-warehouse/editor/OutputPaneTabs/InfoTab.tsx
new file mode 100644
index 0000000000000..1c3bbe26558cc
--- /dev/null
+++ b/frontend/src/scenes/data-warehouse/editor/OutputPaneTabs/InfoTab.tsx
@@ -0,0 +1,111 @@
+import { LemonButton, LemonTag, Tooltip } from '@posthog/lemon-ui'
+import { useActions, useValues } from 'kea'
+import { LemonTable } from 'lib/lemon-ui/LemonTable'
+import { humanFriendlyDetailedTime } from 'lib/utils'
+
+import { multitabEditorLogic } from '../multitabEditorLogic'
+import { infoTabLogic } from './infoTabLogic'
+
+interface InfoTabProps {
+    codeEditorKey: string
+}
+
+export function InfoTab({ codeEditorKey }: InfoTabProps): JSX.Element {
+    const { sourceTableItems } = useValues(infoTabLogic({ codeEditorKey: codeEditorKey }))
+    const { editingView, isEditingMaterializedView } = useValues(multitabEditorLogic)
+    const { runDataWarehouseSavedQuery } = useActions(multitabEditorLogic)
+
+    return (
+        <div className="flex flex-col flex-1 m-4 gap-4">
+            <div>
+                <div className="flex flex-row items-center gap-2">
+                    <h3 className="mb-0">Materialization</h3>
+                    <LemonTag type="warning">BETA</LemonTag>
+                </div>
+                <div>
+                    {isEditingMaterializedView ? (
+                        <div>
+                            {editingView?.last_run_at ? (
+                                `Last run at ${humanFriendlyDetailedTime(editingView.last_run_at)}`
+                            ) : (
+                                <div>
+                                    <span>Materialization scheduled</span>
+                                </div>
+                            )}
+                            <LemonButton
+                                onClick={() => editingView && runDataWarehouseSavedQuery(editingView.id)}
+                                className="mt-2"
+                                type="secondary"
+                            >
+                                Run now
+                            </LemonButton>
+                        </div>
+                    ) : (
+                        <div>
+                            <p>
+                                Materialized views are a way to pre-compute data in your data warehouse. This allows you
+                                to run queries faster and more efficiently.
+                            </p>
+                            <LemonButton
+                                onClick={() => editingView && runDataWarehouseSavedQuery(editingView.id)}
+                                type="primary"
+                                disabledReason={editingView ? undefined : 'You must save the view first'}
+                            >
+                                Materialize
+                            </LemonButton>
+                        </div>
+                    )}
+                </div>
+            </div>
+            <div>
+                <h3>Dependencies</h3>
+                <p>
+                    Dependencies are tables that this query uses. See when a source or materialized table was last run.
+                </p>
+            </div>
+            <LemonTable
+                columns={[
+                    {
+                        key: 'Name',
+                        title: 'Name',
+                        render: (_, { name }) => name,
+                    },
+                    {
+                        key: 'Type',
+                        title: 'Type',
+                        render: (_, { type }) => type,
+                    },
+                    {
+                        key: 'Status',
+                        title: 'Status',
+                        render: (_, { type, status }) => {
+                            if (type === 'source') {
+                                return (
+                                    <Tooltip title="This is a source table, so it doesn't have a status">
+                                        <span className="text-muted">N/A</span>
+                                    </Tooltip>
+                                )
+                            }
+                            return status
+                        },
+                    },
+                    {
+                        key: 'Last run at',
+                        title: 'Last run at',
+                        render: (_, { type, last_run_at }) => {
+                            if (type === 'source') {
+                                return (
+                                    <Tooltip title="This is a source table, so it is never run">
+                                        <span className="text-muted">N/A</span>
+                                    </Tooltip>
+                                )
+                            }
+                            return humanFriendlyDetailedTime(last_run_at)
+                        },
+                    },
+                ]}
+                dataSource={sourceTableItems}
+            />
+        </div>
+    )
+}
diff --git a/frontend/src/scenes/data-warehouse/editor/OutputPaneTabs/infoTabLogic.ts b/frontend/src/scenes/data-warehouse/editor/OutputPaneTabs/infoTabLogic.ts
new file mode 100644
index 0000000000000..4510e80db6693
--- /dev/null
+++ b/frontend/src/scenes/data-warehouse/editor/OutputPaneTabs/infoTabLogic.ts
@@ -0,0 +1,63 @@
+import { connect, kea, key, path, props, selectors } from 'kea'
+import { databaseTableListLogic } from 'scenes/data-management/database/databaseTableListLogic'
+import { dataWarehouseViewsLogic } from 'scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic'
+
+import { multitabEditorLogic } from '../multitabEditorLogic'
+import type { infoTabLogicType } from './infoTabLogicType'
+
+export interface InfoTableRow {
+    name: string
+    type: 'source' | 'table'
+    status?: string
+    last_run_at?: string
+}
+
+export interface InfoTabLogicProps {
+    codeEditorKey: string
+}
+
+export const infoTabLogic = kea<infoTabLogicType>([
+    path(['data-warehouse', 'editor', 'outputPaneTabs', 'infoTabLogic']),
+    props({} as InfoTabLogicProps),
+    key((props) => props.codeEditorKey),
+    connect((props: InfoTabLogicProps) => ({
+        values: [
+            multitabEditorLogic({ key: props.codeEditorKey }),
+            ['metadata'],
+            databaseTableListLogic,
+            ['posthogTablesMap', 'dataWarehouseTablesMap'],
+            dataWarehouseViewsLogic,
+            ['dataWarehouseSavedQueryMap'],
+        ],
+    })),
+    selectors({
+        sourceTableItems: [
+            (s) => [s.metadata, s.dataWarehouseSavedQueryMap],
+            (metadata, dataWarehouseSavedQueryMap) => {
+                if (!metadata) {
+                    return []
+                }
+                return (
+                    metadata.table_names?.map((table_name) => {
+                        const view = dataWarehouseSavedQueryMap[table_name]
+                        if (view) {
+                            return {
+                                name: table_name,
+                                type: 'table',
+                                status: view.status,
+                                last_run_at: view.last_run_at || 'never',
+                            }
+                        }
+
+                        return {
+                            name: table_name,
+                            type: 'source',
+                            status: undefined,
+                            last_run_at: undefined,
+                        }
+                    }) || []
+                )
+            },
+        ],
+    }),
+])
diff --git a/frontend/src/scenes/data-warehouse/editor/QueryPane.tsx b/frontend/src/scenes/data-warehouse/editor/QueryPane.tsx
index 10e36c436e739..502084bee80e6 100644
--- a/frontend/src/scenes/data-warehouse/editor/QueryPane.tsx
+++ b/frontend/src/scenes/data-warehouse/editor/QueryPane.tsx
@@ -3,12 +3,15 @@ import { Resizer } from 'lib/components/Resizer/Resizer'
 import { CodeEditor, CodeEditorProps } from 'lib/monaco/CodeEditor'
 import { AutoSizer } from 'react-virtualized/dist/es/AutoSizer'
 
+import { HogQLQuery } from '~/queries/schema'
+
 import { editorSizingLogic } from './editorSizingLogic'
 
 interface QueryPaneProps {
     queryInput: string
     promptError: string | null
     codeEditorProps: Partial<CodeEditorProps>
+    sourceQuery: HogQLQuery
 }
 
 export function QueryPane(props: QueryPaneProps): JSX.Element {
@@ -31,6 +34,7 @@ export function QueryPane(props: QueryPaneProps): JSX.Element {
                                 className="border"
                                 language="hogQL"
                                 value={props.queryInput}
+                                sourceQuery={props.sourceQuery}
                                 height={height}
                                 width={width}
                                 {...props.codeEditorProps}
diff --git a/frontend/src/scenes/data-warehouse/editor/QueryTabs.tsx b/frontend/src/scenes/data-warehouse/editor/QueryTabs.tsx
index 35a41c0f402b7..85c9d80ef6270 100644
--- a/frontend/src/scenes/data-warehouse/editor/QueryTabs.tsx
+++ b/frontend/src/scenes/data-warehouse/editor/QueryTabs.tsx
@@ -14,7 +14,7 @@ interface QueryTabsProps {
 
 export function QueryTabs({ models, onClear, onClick, onAdd, activeModelUri }: QueryTabsProps): JSX.Element {
     return (
-        <div className="flex flex-row overflow-scroll hide-scrollbar h-10">
+        <div className="flex flex-row w-full overflow-scroll hide-scrollbar h-10">
             {models.map((model: QueryTab) => (
                 <QueryTabComponent
                     key={model.uri.path}
diff --git a/frontend/src/scenes/data-warehouse/editor/QueryWindow.tsx b/frontend/src/scenes/data-warehouse/editor/QueryWindow.tsx
index fa8f52c604781..7bfbe9310d7e8 100644
--- a/frontend/src/scenes/data-warehouse/editor/QueryWindow.tsx
+++ b/frontend/src/scenes/data-warehouse/editor/QueryWindow.tsx
@@ -1,10 +1,23 @@
 import { Monaco } from '@monaco-editor/react'
-import { useActions, useValues } from 'kea'
+import { BindLogic, useActions, useValues } from 'kea'
 import { router } from 'kea-router'
 import type { editor as importedEditor } from 'monaco-editor'
 import { useState } from 'react'
 
-import { multitabEditorLogic } from './multitabEditorLogic'
+import { dataNodeLogic, DataNodeLogicProps } from '~/queries/nodes/DataNode/dataNodeLogic'
+import { variableModalLogic } from '~/queries/nodes/DataVisualization/Components/Variables/variableModalLogic'
+import {
+    variablesLogic,
+    VariablesLogicProps,
+} from '~/queries/nodes/DataVisualization/Components/Variables/variablesLogic'
+import {
+    dataVisualizationLogic,
+    DataVisualizationLogicProps,
+} from '~/queries/nodes/DataVisualization/dataVisualizationLogic'
+import { displayLogic } from '~/queries/nodes/DataVisualization/displayLogic'
+import { ItemMode } from '~/types'
+
+import { dataNodeKey, multitabEditorLogic } from './multitabEditorLogic'
 import { OutputPane } from './OutputPane'
 import { QueryPane } from './QueryPane'
 import { QueryTabs } from './QueryTabs'
@@ -14,7 +27,6 @@ export function QueryWindow(): JSX.Element {
         null as [Monaco, importedEditor.IStandaloneCodeEditor] | null
     )
     const [monaco, editor] = monacoAndEditor ?? []
-
     const codeEditorKey = `hogQLQueryEditor/${router.values.location.pathname}`
 
     const logic = multitabEditorLogic({
@@ -22,37 +34,35 @@ export function QueryWindow(): JSX.Element {
         monaco,
         editor,
     })
-    const {
-        allTabs,
-        activeModelUri,
-        queryInput,
-        activeQuery,
-        activeTabKey,
-        hasErrors,
-        error,
-        isValidView,
-        editingView,
-    } = useValues(logic)
-    const { selectTab, deleteTab, createTab, setQueryInput, runQuery, saveAsView } = useActions(logic)
+
+    const { allTabs, activeModelUri, queryInput, editingView, sourceQuery } = useValues(logic)
+    const { selectTab, deleteTab, createTab, setQueryInput, runQuery, setError, setIsValidView, setMetadata } =
+        useActions(logic)
 
     return (
-        <div className="flex flex-1 flex-col h-full">
-            <QueryTabs
-                models={allTabs}
-                onClick={selectTab}
-                onClear={deleteTab}
-                onAdd={createTab}
-                activeModelUri={activeModelUri}
-            />
+        <div className="flex flex-1 flex-col h-full overflow-hidden">
+            <div className="overflow-x-auto">
+                <QueryTabs
+                    models={allTabs}
+                    onClick={selectTab}
+                    onClear={deleteTab}
+                    onAdd={createTab}
+                    activeModelUri={activeModelUri}
+                />
+            </div>
             {editingView && (
                 <div className="h-7 bg-warning-highlight p-1">
-                    <span> Editing view "{editingView.name}"</span>
+                    <span>
+                        Editing {editingView.status ? 'materialized view' : 'view'} "{editingView.name}"
+                    </span>
                 </div>
             )}
             <QueryPane
                 queryInput={queryInput}
+                sourceQuery={sourceQuery.source}
                 promptError={null}
                 codeEditorProps={{
+                    queryKey: codeEditorKey,
                     onChange: (v) => {
                         setQueryInput(v ?? '')
                     },
@@ -66,17 +76,70 @@ export function QueryWindow(): JSX.Element {
                             runQuery()
                         }
                     },
+                    onError: (error, isValidView) => {
+                        setError(error)
+                        setIsValidView(isValidView)
+                    },
+                    onMetadata: (metadata) => {
+                        setMetadata(metadata)
+                    },
                 }}
             />
-            <OutputPane
-                logicKey={activeTabKey}
-                query={activeQuery ?? ''}
-                onQueryInputChange={runQuery}
-                onSave={saveAsView}
-                saveDisabledReason={
-                    hasErrors ? error ?? 'Query has errors' : !isValidView ? 'Some fields may need an alias' : ''
-                }
-            />
+            <BindLogic logic={multitabEditorLogic} props={{ key: codeEditorKey, monaco, editor }}>
+                <InternalQueryWindow />
+            </BindLogic>
         </div>
     )
 }
+
+function InternalQueryWindow(): JSX.Element | null {
+    const { cacheLoading, sourceQuery, queryInput } = useValues(multitabEditorLogic)
+    const { setSourceQuery } = useActions(multitabEditorLogic)
+
+    // NOTE: hacky way to avoid flicker loading
+    if (cacheLoading) {
+        return null
+    }
+
+    const dataVisualizationLogicProps: DataVisualizationLogicProps = {
+        key: dataNodeKey,
+        query: sourceQuery,
+        dashboardId: undefined,
+        dataNodeCollectionId: dataNodeKey,
+        insightMode: ItemMode.Edit,
+        loadPriority: undefined,
+        cachedResults: undefined,
+        variablesOverride: undefined,
+        setQuery: setSourceQuery,
+    }
+
+    const dataNodeLogicProps: DataNodeLogicProps = {
+        query: sourceQuery.source,
+        key: dataNodeKey,
+        cachedResults: undefined,
+        loadPriority: undefined,
+        dataNodeCollectionId: dataNodeKey,
+        variablesOverride: undefined,
+        autoLoad: false,
+    }
+
+    const variablesLogicProps: VariablesLogicProps = {
+        key: dataVisualizationLogicProps.key,
+        readOnly: false,
+        queryInput,
+    }
+
+    return (
+        <BindLogic logic={dataNodeLogic} props={dataNodeLogicProps}>
+            <BindLogic logic={dataVisualizationLogic} props={dataVisualizationLogicProps}>
+                <BindLogic logic={displayLogic} props={{ key: dataVisualizationLogicProps.key }}>
+                    <BindLogic logic={variablesLogic} props={variablesLogicProps}>
+                        <BindLogic logic={variableModalLogic} props={{ key: dataVisualizationLogicProps.key }}>
+                            <OutputPane />
+                        </BindLogic>
+                    </BindLogic>
+                </BindLogic>
+            </BindLogic>
+        </BindLogic>
+    )
+}
diff --git a/frontend/src/scenes/data-warehouse/editor/editorSidebarLogic.ts b/frontend/src/scenes/data-warehouse/editor/editorSidebarLogic.tsx
similarity index 63%
rename from frontend/src/scenes/data-warehouse/editor/editorSidebarLogic.ts
rename to frontend/src/scenes/data-warehouse/editor/editorSidebarLogic.tsx
index c7128d138beea..c45ea5559fb5a 100644
--- a/frontend/src/scenes/data-warehouse/editor/editorSidebarLogic.ts
+++ b/frontend/src/scenes/data-warehouse/editor/editorSidebarLogic.tsx
@@ -1,9 +1,9 @@
+import { Tooltip } from '@posthog/lemon-ui'
 import Fuse from 'fuse.js'
 import { connect, kea, path, selectors } from 'kea'
 import { router } from 'kea-router'
 import { subscriptions } from 'kea-subscriptions'
-import { FEATURE_FLAGS } from 'lib/constants'
-import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { IconCalculate, IconClipboardEdit } from 'lib/lemon-ui/icons'
 import { databaseTableListLogic } from 'scenes/data-management/database/databaseTableListLogic'
 import { sceneLogic } from 'scenes/sceneLogic'
 import { Scene } from 'scenes/sceneTypes'
@@ -42,20 +42,6 @@ const savedQueriesfuse = new Fuse<DataWarehouseSavedQuery>([], {
     includeMatches: true,
 })
 
-const nonMaterializedViewsfuse = new Fuse<DataWarehouseSavedQuery>([], {
-    keys: [{ name: 'name', weight: 2 }],
-    threshold: 0.3,
-    ignoreLocation: true,
-    includeMatches: true,
-})
-
-const materializedViewsfuse = new Fuse<DataWarehouseSavedQuery>([], {
-    keys: [{ name: 'name', weight: 2 }],
-    threshold: 0.3,
-    ignoreLocation: true,
-    includeMatches: true,
-})
-
 export const editorSidebarLogic = kea<editorSidebarLogicType>([
     path(['data-warehouse', 'editor', 'editorSidebarLogic']),
     connect({
@@ -66,8 +52,6 @@ export const editorSidebarLogic = kea<editorSidebarLogicType>([
             ['dataWarehouseSavedQueries', 'dataWarehouseSavedQueryMapById', 'dataWarehouseSavedQueriesLoading'],
             databaseTableListLogic,
             ['posthogTables', 'dataWarehouseTables', 'databaseLoading', 'views', 'viewsMapById'],
-            featureFlagLogic,
-            ['featureFlags'],
         ],
         actions: [
             editorSceneLogic,
@@ -86,19 +70,13 @@ export const editorSidebarLogic = kea<editorSidebarLogicType>([
                 s.relevantPosthogTables,
                 s.relevantDataWarehouseTables,
                 s.databaseLoading,
-                s.relevantNonMaterializedViews,
-                s.relevantMaterializedViews,
-                s.featureFlags,
             ],
             (
                 relevantSavedQueries,
                 dataWarehouseSavedQueriesLoading,
                 relevantPosthogTables,
                 relevantDataWarehouseTables,
-                databaseLoading,
-                relevantNonMaterializedViews,
-                relevantMaterializedViews,
-                featureFlags
+                databaseLoading
             ) => [
                 {
                     key: 'data-warehouse-sources',
@@ -163,13 +141,19 @@ export const editorSidebarLogic = kea<editorSidebarLogicType>([
                     key: 'data-warehouse-views',
                     noun: ['view', 'views'],
                     loading: dataWarehouseSavedQueriesLoading,
-                    items: (featureFlags[FEATURE_FLAGS.DATA_MODELING]
-                        ? relevantNonMaterializedViews
-                        : relevantSavedQueries
-                    ).map(([savedQuery, matches]) => ({
+                    items: relevantSavedQueries.map(([savedQuery, matches]) => ({
                         key: savedQuery.id,
                         name: savedQuery.name,
                         url: '',
+                        icon: savedQuery.status ? (
+                            <Tooltip title="Materialized view">
+                                <IconCalculate />
+                            </Tooltip>
+                        ) : (
+                            <Tooltip title="View">
+                                <IconClipboardEdit />
+                            </Tooltip>
+                        ),
                         searchMatch: matches
                             ? {
                                   matchingFields: matches.map((match) => match.key),
@@ -185,7 +169,7 @@ export const editorSidebarLogic = kea<editorSidebarLogicType>([
                                 onClick: () => {
                                     multitabEditorLogic({
                                         key: `hogQLQueryEditor/${router.values.location.pathname}`,
-                                    }).actions.createTab(savedQuery.query.query, savedQuery)
+                                    }).actions.editView(savedQuery.query.query, savedQuery)
                                 },
                             },
                             {
@@ -195,16 +179,6 @@ export const editorSidebarLogic = kea<editorSidebarLogicType>([
                                     actions.toggleJoinTableModal()
                                 },
                             },
-                            ...(featureFlags[FEATURE_FLAGS.DATA_MODELING] && !savedQuery.status
-                                ? [
-                                      {
-                                          label: 'Materialize',
-                                          onClick: () => {
-                                              actions.runDataWarehouseSavedQuery(savedQuery.id)
-                                          },
-                                      },
-                                  ]
-                                : []),
                             {
                                 label: 'Delete',
                                 status: 'danger',
@@ -215,63 +189,6 @@ export const editorSidebarLogic = kea<editorSidebarLogicType>([
                         ],
                     })),
                 } as SidebarCategory,
-                ...(featureFlags[FEATURE_FLAGS.DATA_MODELING]
-                    ? [
-                          {
-                              key: 'data-warehouse-materialized-views',
-                              noun: ['materialized view', 'materialized views'],
-                              loading: dataWarehouseSavedQueriesLoading,
-                              items: relevantMaterializedViews.map(([materializedView, matches]) => ({
-                                  key: materializedView.id,
-                                  name: materializedView.name,
-                                  url: '',
-                                  searchMatch: matches
-                                      ? {
-                                            matchingFields: matches.map((match) => match.key),
-                                            nameHighlightRanges: matches.find((match) => match.key === 'name')?.indices,
-                                        }
-                                      : null,
-                                  onClick: () => {
-                                      actions.selectSchema(materializedView)
-                                  },
-                                  menuItems: [
-                                      {
-                                          label: 'Edit view definition',
-                                          onClick: () => {
-                                              multitabEditorLogic({
-                                                  key: `hogQLQueryEditor/${router.values.location.pathname}`,
-                                              }).actions.createTab(materializedView.query.query, materializedView)
-                                          },
-                                      },
-                                      {
-                                          label: 'Add join',
-                                          onClick: () => {
-                                              actions.selectSourceTable(materializedView.name)
-                                              actions.toggleJoinTableModal()
-                                          },
-                                      },
-                                      ...(featureFlags[FEATURE_FLAGS.DATA_MODELING] && materializedView.status
-                                          ? [
-                                                {
-                                                    label: 'Run',
-                                                    onClick: () => {
-                                                        actions.runDataWarehouseSavedQuery(materializedView.id)
-                                                    },
-                                                },
-                                            ]
-                                          : []),
-                                      {
-                                          label: 'Delete',
-                                          status: 'danger',
-                                          onClick: () => {
-                                              actions.deleteDataWarehouseSavedQuery(materializedView.id)
-                                          },
-                                      },
-                                  ],
-                              })),
-                          },
-                      ]
-                    : []),
             ],
         ],
         nonMaterializedViews: [
@@ -327,28 +244,6 @@ export const editorSidebarLogic = kea<editorSidebarLogicType>([
                 return dataWarehouseSavedQueries.map((savedQuery) => [savedQuery, null])
             },
         ],
-        relevantNonMaterializedViews: [
-            (s) => [s.nonMaterializedViews, navigation3000Logic.selectors.searchTerm],
-            (nonMaterializedViews, searchTerm): [DataWarehouseSavedQuery, FuseSearchMatch[] | null][] => {
-                if (searchTerm) {
-                    return nonMaterializedViewsfuse
-                        .search(searchTerm)
-                        .map((result) => [result.item, result.matches as FuseSearchMatch[]])
-                }
-                return nonMaterializedViews.map((view) => [view, null])
-            },
-        ],
-        relevantMaterializedViews: [
-            (s) => [s.materializedViews, navigation3000Logic.selectors.searchTerm],
-            (materializedViews, searchTerm): [DataWarehouseSavedQuery, FuseSearchMatch[] | null][] => {
-                if (searchTerm) {
-                    return materializedViewsfuse
-                        .search(searchTerm)
-                        .map((result) => [result.item, result.matches as FuseSearchMatch[]])
-                }
-                return materializedViews.map((view) => [view, null])
-            },
-        ],
     })),
     subscriptions({
         dataWarehouseTables: (dataWarehouseTables) => {
diff --git a/frontend/src/scenes/data-warehouse/editor/editorSizingLogic.tsx b/frontend/src/scenes/data-warehouse/editor/editorSizingLogic.tsx
index 25bc04388e5a0..397bad5ff33d5 100644
--- a/frontend/src/scenes/data-warehouse/editor/editorSizingLogic.tsx
+++ b/frontend/src/scenes/data-warehouse/editor/editorSizingLogic.tsx
@@ -13,7 +13,7 @@ export interface EditorSizingLogicProps {
 const MINIMUM_NAVIGATOR_WIDTH = 100
 const NAVIGATOR_DEFAULT_WIDTH = 350
 const MINIMUM_QUERY_PANE_HEIGHT = 100
-const DEFAULT_QUERY_PANE_HEIGHT = 600
+const DEFAULT_QUERY_PANE_HEIGHT = 400
 
 export const editorSizingLogic = kea<editorSizingLogicType>([
     path(['scenes', 'data-warehouse', 'editor', 'editorSizingLogic']),
diff --git a/frontend/src/scenes/data-warehouse/editor/multitabEditorLogic.tsx b/frontend/src/scenes/data-warehouse/editor/multitabEditorLogic.tsx
index c6b9e4ed575c9..94995a446ae2d 100644
--- a/frontend/src/scenes/data-warehouse/editor/multitabEditorLogic.tsx
+++ b/frontend/src/scenes/data-warehouse/editor/multitabEditorLogic.tsx
@@ -1,19 +1,32 @@
 import { Monaco } from '@monaco-editor/react'
 import { LemonDialog, LemonInput, lemonToast } from '@posthog/lemon-ui'
 import { actions, connect, kea, key, listeners, path, props, propsChanged, reducers, selectors } from 'kea'
+import { router } from 'kea-router'
 import { subscriptions } from 'kea-subscriptions'
 import { LemonField } from 'lib/lemon-ui/LemonField'
-import { ModelMarker } from 'lib/monaco/codeEditorLogic'
-import { editor, MarkerSeverity, Uri } from 'monaco-editor'
+import { initModel } from 'lib/monaco/CodeEditor'
+import { codeEditorLogic } from 'lib/monaco/codeEditorLogic'
+import { editor, Uri } from 'monaco-editor'
+import { insightsApi } from 'scenes/insights/utils/api'
+import { urls } from 'scenes/urls'
 
 import { dataNodeLogic } from '~/queries/nodes/DataNode/dataNodeLogic'
-import { performQuery } from '~/queries/query'
-import { HogLanguage, HogQLMetadata, HogQLMetadataResponse, HogQLNotice, HogQLQuery, NodeKind } from '~/queries/schema'
-import { DataWarehouseSavedQuery } from '~/types'
+import { insightVizDataNodeKey } from '~/queries/nodes/InsightViz/InsightViz'
+import { queryExportContext } from '~/queries/query'
+import { HogQLMetadataResponse, HogQLQuery, NodeKind } from '~/queries/schema'
+import { DataVisualizationNode } from '~/queries/schema'
+import { DataWarehouseSavedQuery, ExportContext } from '~/types'
 
+import { DATAWAREHOUSE_EDITOR_ITEM_ID } from '../external/dataWarehouseExternalSceneLogic'
 import { dataWarehouseViewsLogic } from '../saved_queries/dataWarehouseViewsLogic'
 import type { multitabEditorLogicType } from './multitabEditorLogicType'
 
+export const dataNodeKey = insightVizDataNodeKey({
+    dashboardItemId: DATAWAREHOUSE_EDITOR_ITEM_ID,
+    cachedInsight: null,
+    doNotLoad: true,
+})
+
 export interface MultitabEditorLogicProps {
     key: string
     monaco?: Monaco | null
@@ -35,13 +48,18 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
     connect({
         actions: [
             dataWarehouseViewsLogic,
-            ['deleteDataWarehouseSavedQuerySuccess', 'createDataWarehouseSavedQuerySuccess'],
+            [
+                'loadDataWarehouseSavedQueriesSuccess',
+                'deleteDataWarehouseSavedQuerySuccess',
+                'createDataWarehouseSavedQuerySuccess',
+                'runDataWarehouseSavedQuery',
+            ],
         ],
     }),
     actions({
         setQueryInput: (queryInput: string) => ({ queryInput }),
         updateState: true,
-        runQuery: (queryOverride?: string) => ({ queryOverride }),
+        runQuery: (queryOverride?: string, switchTab?: boolean) => ({ queryOverride, switchTab }),
         setActiveQuery: (query: string) => ({ query }),
         setTabs: (tabs: QueryTab[]) => ({ tabs }),
         addTab: (tab: QueryTab) => ({ tab }),
@@ -53,8 +71,14 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
         initialize: true,
         saveAsView: true,
         saveAsViewSubmit: (name: string) => ({ name }),
-        reloadMetadata: true,
-        setMetadata: (query: string, metadata: HogQLMetadataResponse) => ({ query, metadata }),
+        saveAsInsight: true,
+        saveAsInsightSubmit: (name: string) => ({ name }),
+        setCacheLoading: (loading: boolean) => ({ loading }),
+        setError: (error: string | null) => ({ error }),
+        setIsValidView: (isValidView: boolean) => ({ isValidView }),
+        setSourceQuery: (sourceQuery: DataVisualizationNode) => ({ sourceQuery }),
+        setMetadata: (metadata: HogQLMetadataResponse) => ({ metadata }),
+        editView: (query: string, view: DataWarehouseSavedQuery) => ({ query, view }),
     }),
     propsChanged(({ actions, props }, oldProps) => {
         if (!oldProps.monaco && !oldProps.editor && props.monaco && props.editor) {
@@ -62,6 +86,24 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
         }
     }),
     reducers(({ props }) => ({
+        cacheLoading: [
+            true,
+            {
+                setCacheLoading: (_, { loading }) => loading,
+            },
+        ],
+        sourceQuery: [
+            {
+                kind: NodeKind.DataVisualizationNode,
+                source: {
+                    kind: NodeKind.HogQLQuery,
+                    query: '',
+                },
+            } as DataVisualizationNode,
+            {
+                setSourceQuery: (_, { sourceQuery }) => sourceQuery,
+            },
+        ],
         queryInput: [
             '',
             {
@@ -100,57 +142,37 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                 setTabs: (_, { tabs }) => tabs,
             },
         ],
-        metadata: [
-            null as null | [string, HogQLMetadataResponse],
+        error: [
+            null as string | null,
             {
-                setMetadata: (_, { query, metadata }) => [query, metadata],
+                setError: (_, { error }) => error,
             },
         ],
-        modelMarkers: [
-            [] as ModelMarker[],
+        isValidView: [
+            false,
             {
-                setMetadata: (_, { query, metadata }) => {
-                    const model = props.editor?.getModel()
-                    if (!model || !metadata) {
-                        return []
-                    }
-                    const markers: ModelMarker[] = []
-                    const metadataResponse = metadata
-
-                    function noticeToMarker(error: HogQLNotice, severity: MarkerSeverity): ModelMarker {
-                        const start = model!.getPositionAt(error.start ?? 0)
-                        const end = model!.getPositionAt(error.end ?? query.length)
-                        return {
-                            start: error.start ?? 0,
-                            startLineNumber: start.lineNumber,
-                            startColumn: start.column,
-                            end: error.end ?? query.length,
-                            endLineNumber: end.lineNumber,
-                            endColumn: end.column,
-                            message: error.message ?? 'Unknown error',
-                            severity: severity,
-                            hogQLFix: error.fix,
-                        }
-                    }
-
-                    for (const notice of metadataResponse?.errors ?? []) {
-                        markers.push(noticeToMarker(notice, 8 /* MarkerSeverity.Error */))
-                    }
-                    for (const notice of metadataResponse?.warnings ?? []) {
-                        markers.push(noticeToMarker(notice, 4 /* MarkerSeverity.Warning */))
-                    }
-                    for (const notice of metadataResponse?.notices ?? []) {
-                        markers.push(noticeToMarker(notice, 1 /* MarkerSeverity.Hint */))
-                    }
-
-                    props.monaco?.editor.setModelMarkers(model, 'hogql', markers)
-                    return markers
-                },
+                setIsValidView: (_, { isValidView }) => isValidView,
+            },
+        ],
+        metadata: [
+            null as HogQLMetadataResponse | null,
+            {
+                setMetadata: (_, { metadata }) => metadata,
             },
         ],
+        editorKey: [props.key],
     })),
     listeners(({ values, props, actions, asyncActions }) => ({
+        editView: ({ query, view }) => {
+            const maybeExistingTab = values.allTabs.find((tab) => tab.view?.id === view.id)
+            if (maybeExistingTab) {
+                actions.selectTab(maybeExistingTab)
+            } else {
+                actions.createTab(query, view)
+            }
+        },
         createTab: ({ query = '', view }) => {
+            const mountedCodeEditorLogic = codeEditorLogic.findMounted()
             let currentModelCount = 1
             const allNumbers = values.allTabs.map((tab) => parseInt(tab.uri.path.split('/').pop() || '0'))
             while (allNumbers.includes(currentModelCount)) {
@@ -161,6 +183,11 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                 const uri = props.monaco.Uri.parse(currentModelCount.toString())
                 const model = props.monaco.editor.createModel(query, 'hogQL', uri)
                 props.editor?.setModel(model)
+
+                if (mountedCodeEditorLogic) {
+                    initModel(model, mountedCodeEditorLogic)
+                }
+
                 actions.addTab({
                     uri,
                     view,
@@ -218,6 +245,13 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
         initialize: () => {
             const allModelQueries = localStorage.getItem(editorModelsStateKey(props.key))
             const activeModelUri = localStorage.getItem(activemodelStateKey(props.key))
+            const mountedCodeEditorLogic =
+                codeEditorLogic.findMounted() ||
+                codeEditorLogic({
+                    key: props.key,
+                    query: values.sourceQuery?.source.query ?? '',
+                    language: 'hogQL',
+                })
 
             if (allModelQueries) {
                 // clear existing models
@@ -237,6 +271,7 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                             uri,
                             view: model.view,
                         })
+                        mountedCodeEditorLogic && initModel(newModel, mountedCodeEditorLogic)
                     }
                 })
 
@@ -272,6 +307,7 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                     actions.createTab()
                 }
             }
+            actions.setCacheLoading(false)
         },
         setQueryInput: () => {
             actions.updateState()
@@ -287,18 +323,24 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
             })
             localStorage.setItem(editorModelsStateKey(props.key), JSON.stringify(queries))
         },
-        runQuery: ({ queryOverride }) => {
-            if (values.activeQuery === queryOverride || values.activeQuery === values.queryInput) {
-                dataNodeLogic({
-                    key: values.activeTabKey,
-                    query: {
-                        kind: NodeKind.HogQLQuery,
-                        query: queryOverride || values.queryInput,
-                    },
-                    alwaysRefresh: true,
-                }).actions.loadData(true)
-            }
-            actions.setActiveQuery(queryOverride || values.queryInput)
+        runQuery: ({ queryOverride, switchTab }) => {
+            const query = queryOverride || values.queryInput
+
+            actions.setSourceQuery({
+                ...values.sourceQuery,
+                source: {
+                    ...values.sourceQuery.source,
+                    query,
+                },
+            })
+            dataNodeLogic({
+                key: dataNodeKey,
+                query: {
+                    ...values.sourceQuery.source,
+                    query,
+                },
+                autoLoad: false,
+            }).actions.loadData(!switchTab)
         },
         saveAsView: async () => {
             LemonDialog.openForm({
@@ -319,41 +361,53 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
             })
         },
         saveAsViewSubmit: async ({ name }) => {
-            const query: HogQLQuery = {
-                kind: NodeKind.HogQLQuery,
-                query: values.queryInput,
-            }
+            const query: HogQLQuery = values.sourceQuery.source
 
             const logic = dataNodeLogic({
-                key: values.activeTabKey,
-                query: {
-                    kind: NodeKind.HogQLQuery,
-                    query: values.queryInput,
-                },
+                key: dataNodeKey,
+                query,
             })
 
             const types = logic.values.response?.types ?? []
 
             await dataWarehouseViewsLogic.asyncActions.createDataWarehouseSavedQuery({ name, query, types })
         },
-        reloadMetadata: async (_, breakpoint) => {
-            const model = props.editor?.getModel()
-            if (!model || !props.monaco) {
-                return
-            }
-            await breakpoint(300)
-            const query = values.queryInput
-            if (query === '') {
-                return
-            }
-
-            const response = await performQuery<HogQLMetadata>({
-                kind: NodeKind.HogQLMetadata,
-                language: HogLanguage.hogQL,
-                query: query,
+        saveAsInsight: async () => {
+            LemonDialog.openForm({
+                title: 'Save as new insight',
+                initialValues: {
+                    name: '',
+                },
+                content: (
+                    <LemonField name="name">
+                        <LemonInput data-attr="insight-name" placeholder="Please enter the new name" autoFocus />
+                    </LemonField>
+                ),
+                errors: {
+                    name: (name) => (!name ? 'You must enter a name' : undefined),
+                },
+                onSubmit: async ({ name }) => actions.saveAsInsightSubmit(name),
             })
-            breakpoint()
-            actions.setMetadata(query, response)
+        },
+        saveAsInsightSubmit: async ({ name }) => {
+            const insight = await insightsApi.create({
+                name,
+                query: values.sourceQuery,
+                saved: true,
+            })
+
+            lemonToast.info(`You're now viewing ${insight.name || insight.derived_name || name}`)
+
+            router.actions.push(urls.insightView(insight.short_id))
+        },
+        loadDataWarehouseSavedQueriesSuccess: ({ dataWarehouseSavedQueries }) => {
+            // keep tab views up to date
+            const newTabs = values.allTabs.map((tab) => ({
+                ...tab,
+                view: dataWarehouseSavedQueries.find((v) => v.id === tab.view?.id),
+            }))
+            actions.setTabs(newTabs)
+            actions.updateState()
         },
         deleteDataWarehouseSavedQuerySuccess: ({ payload: viewId }) => {
             const tabToRemove = values.allTabs.find((tab) => tab.view?.id === viewId)
@@ -385,35 +439,32 @@ export const multitabEditorLogic = kea<multitabEditorLogicType>([
                 const _model = props.monaco.editor.getModel(activeModelUri.uri)
                 const val = _model?.getValue()
                 actions.setQueryInput(val ?? '')
-                actions.runQuery()
-                dataNodeLogic({
-                    key: values.activeTabKey,
-                    query: {
-                        kind: NodeKind.HogQLQuery,
-                        query: val ?? '',
-                    },
-                    doNotLoad: !val,
-                }).mount()
+                actions.runQuery(undefined, true)
             }
         },
-        queryInput: () => {
-            actions.reloadMetadata()
+        allTabs: () => {
+            // keep selected tab up to date
+            const activeTab = values.allTabs.find((tab) => tab.uri.path === values.activeModelUri?.uri.path)
+            activeTab && actions.selectTab(activeTab)
         },
     })),
     selectors({
-        activeTabKey: [(s) => [s.activeModelUri], (activeModelUri) => `hogQLQueryEditor/${activeModelUri?.uri.path}`],
-        isValidView: [(s) => [s.metadata], (metadata) => !!(metadata && metadata[1]?.isValidView)],
-        hasErrors: [
-            (s) => [s.modelMarkers],
-            (modelMarkers) => !!(modelMarkers ?? []).filter((e) => e.severity === 8 /* MarkerSeverity.Error */).length,
+        exportContext: [
+            (s) => [s.sourceQuery],
+            (sourceQuery) => {
+                // TODO: use active tab at some point
+                const filename = 'export'
+
+                return {
+                    ...queryExportContext(sourceQuery.source, undefined, undefined),
+                    filename,
+                } as ExportContext
+            },
         ],
-        error: [
-            (s) => [s.hasErrors, s.modelMarkers],
-            (hasErrors, modelMarkers) => {
-                const firstError = modelMarkers.find((e) => e.severity === 8 /* MarkerSeverity.Error */)
-                return hasErrors && firstError
-                    ? `Error on line ${firstError.startLineNumber}, column ${firstError.startColumn}`
-                    : null
+        isEditingMaterializedView: [
+            (s) => [s.editingView],
+            (editingView) => {
+                return !!editingView?.status
             },
         ],
     }),
diff --git a/frontend/src/scenes/data-warehouse/editor/outputPaneLogic.ts b/frontend/src/scenes/data-warehouse/editor/outputPaneLogic.ts
index 659c79b440635..4e06f611dc49d 100644
--- a/frontend/src/scenes/data-warehouse/editor/outputPaneLogic.ts
+++ b/frontend/src/scenes/data-warehouse/editor/outputPaneLogic.ts
@@ -5,6 +5,7 @@ import type { outputPaneLogicType } from './outputPaneLogicType'
 export enum OutputTab {
     Results = 'results',
     Visualization = 'visualization',
+    Info = 'info',
 }
 
 export const outputPaneLogic = kea<outputPaneLogicType>([
diff --git a/frontend/src/scenes/data-warehouse/new/sourceWizardLogic.tsx b/frontend/src/scenes/data-warehouse/new/sourceWizardLogic.tsx
index a924b0ba594b7..f8e1a5a131205 100644
--- a/frontend/src/scenes/data-warehouse/new/sourceWizardLogic.tsx
+++ b/frontend/src/scenes/data-warehouse/new/sourceWizardLogic.tsx
@@ -513,18 +513,60 @@ export const SOURCE_DETAILS: Record<ExternalDataSourceType, SourceConfig> = {
                 placeholder: 'COMPUTE_WAREHOUSE',
             },
             {
-                name: 'user',
-                label: 'User',
-                type: 'text',
-                required: true,
-                placeholder: 'user',
-            },
-            {
-                name: 'password',
-                label: 'Password',
-                type: 'password',
+                type: 'select',
+                name: 'auth_type',
+                label: 'Authentication type',
                 required: true,
-                placeholder: '',
+                defaultValue: 'password',
+                options: [
+                    {
+                        label: 'Password',
+                        value: 'password',
+                        fields: [
+                            {
+                                name: 'username',
+                                label: 'Username',
+                                type: 'text',
+                                required: true,
+                                placeholder: 'User1',
+                            },
+                            {
+                                name: 'password',
+                                label: 'Password',
+                                type: 'password',
+                                required: true,
+                                placeholder: '',
+                            },
+                        ],
+                    },
+                    {
+                        label: 'Key pair',
+                        value: 'keypair',
+                        fields: [
+                            {
+                                name: 'username',
+                                label: 'Username',
+                                type: 'text',
+                                required: true,
+                                placeholder: 'User1',
+                            },
+                            {
+                                name: 'private_key',
+                                label: 'Private key',
+                                type: 'textarea',
+                                required: true,
+                                placeholder: '',
+                            },
+                            {
+                                name: 'passphrase',
+                                label: 'Passphrase',
+                                type: 'password',
+                                required: false,
+                                placeholder: '',
+                            },
+                        ],
+                    },
+                ],
             },
             {
                 name: 'role',
diff --git a/frontend/src/scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic.tsx b/frontend/src/scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic.tsx
index d66a0285526ba..ae61570189150 100644
--- a/frontend/src/scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic.tsx
+++ b/frontend/src/scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic.tsx
@@ -70,8 +70,13 @@ export const dataWarehouseViewsLogic = kea<dataWarehouseViewsLogicType>([
             actions.loadDatabase()
         },
         runDataWarehouseSavedQuery: async ({ viewId }) => {
-            await api.dataWarehouseSavedQueries.run(viewId)
-            actions.loadDataWarehouseSavedQueries()
+            try {
+                await api.dataWarehouseSavedQueries.run(viewId)
+                lemonToast.success('Materialization started')
+                actions.loadDataWarehouseSavedQueries()
+            } catch (error) {
+                lemonToast.error(`Failed to run materialization`)
+            }
         },
     })),
     selectors({
@@ -92,6 +97,17 @@ export const dataWarehouseViewsLogic = kea<dataWarehouseViewsLogicType>([
                 )
             },
         ],
+        dataWarehouseSavedQueryMap: [
+            (s) => [s.dataWarehouseSavedQueries],
+            (dataWarehouseSavedQueries) => {
+                return (
+                    dataWarehouseSavedQueries?.reduce((acc, cur) => {
+                        acc[cur.name] = cur
+                        return acc
+                    }, {} as Record<string, DataWarehouseSavedQuery>) ?? {}
+                )
+            },
+        ],
     }),
     events(({ actions, cache }) => ({
         afterMount: () => {
diff --git a/frontend/src/scenes/error-tracking/AlphaAccessScenePrompt.tsx b/frontend/src/scenes/error-tracking/AlphaAccessScenePrompt.tsx
new file mode 100644
index 0000000000000..3f9c7b2a50168
--- /dev/null
+++ b/frontend/src/scenes/error-tracking/AlphaAccessScenePrompt.tsx
@@ -0,0 +1,40 @@
+import { LemonButton } from '@posthog/lemon-ui'
+import { useActions } from 'kea'
+import { ProductIntroduction } from 'lib/components/ProductIntroduction/ProductIntroduction'
+import { supportLogic } from 'lib/components/Support/supportLogic'
+import { useFeatureFlag } from 'lib/hooks/useFeatureFlag'
+
+import { ProductKey } from '~/types'
+
+export const AlphaAccessScenePrompt = ({ children }: { children: React.ReactElement }): JSX.Element => {
+    const hasErrorTracking = useFeatureFlag('ERROR_TRACKING')
+    const { openSupportForm } = useActions(supportLogic)
+
+    return hasErrorTracking ? (
+        children
+    ) : (
+        <ProductIntroduction
+            productName="Error tracking"
+            thingName="issue"
+            titleOverride="Capture your first exception"
+            description="Error tracking is in closed alpha for our JS and Python SDKs. If you would like access please reach out and someone on our team will onboard you."
+            isEmpty={true}
+            actionElementOverride={
+                <LemonButton
+                    type="primary"
+                    onClick={() =>
+                        openSupportForm({
+                            target_area: 'error_tracking',
+                            isEmailFormOpen: true,
+                            message: 'Hi\n\nI would like to request access to the error tracking product',
+                            severity_level: 'low',
+                        })
+                    }
+                >
+                    Request access
+                </LemonButton>
+            }
+            productKey={ProductKey.ERROR_TRACKING}
+        />
+    )
+}
diff --git a/frontend/src/scenes/error-tracking/ErrorTrackingConfigurationScene.tsx b/frontend/src/scenes/error-tracking/ErrorTrackingConfigurationScene.tsx
index d381d62640a0f..33c8f2af6779e 100644
--- a/frontend/src/scenes/error-tracking/ErrorTrackingConfigurationScene.tsx
+++ b/frontend/src/scenes/error-tracking/ErrorTrackingConfigurationScene.tsx
@@ -8,6 +8,7 @@ import { humanFriendlyDetailedTime } from 'lib/utils'
 import { useEffect, useState } from 'react'
 import { SceneExport } from 'scenes/sceneTypes'
 
+import { AlphaAccessScenePrompt } from './AlphaAccessScenePrompt'
 import { errorTrackingSymbolSetLogic } from './errorTrackingSymbolSetLogic'
 import { SymbolSetUploadModal } from './SymbolSetUploadModal'
 
@@ -25,19 +26,24 @@ export function ErrorTrackingConfigurationScene(): JSX.Element {
     }, [loadSymbolSets])
 
     return (
-        <div className="space-y-4">
-            <h2>Symbol sets</h2>
-            <p>
-                Source maps are required to demangle any minified code in your exception stack traces. PostHog
-                automatically retrieves source maps where possible. Cases where it was not possible are listed below.
-                Source maps can be uploaded retroactively but changes will only apply to all future exceptions ingested.
-            </p>
-            {missingSymbolSets.length > 0 && (
-                <SymbolSetTable id="missing" dataSource={missingSymbolSets} pageSize={5} missing />
-            )}
-            {validSymbolSets.length > 0 && <SymbolSetTable id="valid" dataSource={validSymbolSets} pageSize={10} />}
-            <SymbolSetUploadModal />
-        </div>
+        <AlphaAccessScenePrompt>
+            <div className="space-y-4">
+                <h2>Symbol sets</h2>
+                <p>
+                    Source maps are required to demangle any minified code in your exception stack traces. PostHog
+                    automatically retrieves source maps where possible. Cases where it was not possible are listed
+                    below. Source maps can be uploaded retroactively but changes will only apply to all future
+                    exceptions ingested.
+                </p>
+                {missingSymbolSets.length > 0 && (
+                    <SymbolSetTable id="missing" dataSource={missingSymbolSets} pageSize={5} missing />
+                )}
+                {(validSymbolSets.length > 0 || missingSymbolSets.length === 0) && (
+                    <SymbolSetTable id="valid" dataSource={validSymbolSets} pageSize={10} />
+                )}
+                <SymbolSetUploadModal />
+            </div>
+        </AlphaAccessScenePrompt>
     )
 }
 
diff --git a/frontend/src/scenes/error-tracking/ErrorTrackingIssueScene.tsx b/frontend/src/scenes/error-tracking/ErrorTrackingIssueScene.tsx
index 7965e2563ae22..33549cf177fa2 100644
--- a/frontend/src/scenes/error-tracking/ErrorTrackingIssueScene.tsx
+++ b/frontend/src/scenes/error-tracking/ErrorTrackingIssueScene.tsx
@@ -8,6 +8,7 @@ import { SceneExport } from 'scenes/sceneTypes'
 
 import { ErrorTrackingIssue } from '~/queries/schema'
 
+import { AlphaAccessScenePrompt } from './AlphaAccessScenePrompt'
 import { AssigneeSelect } from './AssigneeSelect'
 import ErrorTrackingFilters from './ErrorTrackingFilters'
 import { errorTrackingIssueSceneLogic } from './errorTrackingIssueSceneLogic'
@@ -40,47 +41,52 @@ export function ErrorTrackingIssueScene(): JSX.Element {
     }, [])
 
     return (
-        <>
-            <PageHeader
-                buttons={
-                    issue && hasGroupActions ? (
-                        issue.status === 'active' ? (
-                            <div className="flex divide-x gap-x-2">
-                                <AssigneeSelect
-                                    assignee={issue.assignee}
-                                    onChange={(assignee) => updateIssue({ assignee })}
-                                    type="secondary"
-                                    showName
-                                />
-                                <div className="flex pl-2 gap-x-2">
-                                    <LemonButton type="secondary" onClick={() => updateIssue({ status: 'archived' })}>
-                                        Archive
-                                    </LemonButton>
-                                    <LemonButton type="primary" onClick={() => updateIssue({ status: 'resolved' })}>
-                                        Resolve
-                                    </LemonButton>
+        <AlphaAccessScenePrompt>
+            <>
+                <PageHeader
+                    buttons={
+                        issue && hasGroupActions ? (
+                            issue.status === 'active' ? (
+                                <div className="flex divide-x gap-x-2">
+                                    <AssigneeSelect
+                                        assignee={issue.assignee}
+                                        onChange={(assignee) => updateIssue({ assignee })}
+                                        type="secondary"
+                                        showName
+                                    />
+                                    <div className="flex pl-2 gap-x-2">
+                                        <LemonButton
+                                            type="secondary"
+                                            onClick={() => updateIssue({ status: 'archived' })}
+                                        >
+                                            Archive
+                                        </LemonButton>
+                                        <LemonButton type="primary" onClick={() => updateIssue({ status: 'resolved' })}>
+                                            Resolve
+                                        </LemonButton>
+                                    </div>
                                 </div>
-                            </div>
+                            ) : (
+                                <LemonButton
+                                    type="secondary"
+                                    className="upcasefirst-letter:uppercase"
+                                    onClick={() => updateIssue({ status: 'active' })}
+                                    tooltip="Mark as active"
+                                >
+                                    {STATUS_LABEL[issue.status]}
+                                </LemonButton>
+                            )
                         ) : (
-                            <LemonButton
-                                type="secondary"
-                                className="upcasefirst-letter:uppercase"
-                                onClick={() => updateIssue({ status: 'active' })}
-                                tooltip="Mark as active"
-                            >
-                                {STATUS_LABEL[issue.status]}
-                            </LemonButton>
+                            false
                         )
-                    ) : (
-                        false
-                    )
-                }
-            />
-            <ErrorTrackingFilters.FilterGroup />
-            <LemonDivider className="mt-2" />
-            <ErrorTrackingFilters.Options isGroup />
-            <OverviewTab />
-            <SymbolSetUploadModal />
-        </>
+                    }
+                />
+                <ErrorTrackingFilters.FilterGroup />
+                <LemonDivider className="mt-2" />
+                <ErrorTrackingFilters.Options isGroup />
+                <OverviewTab />
+                <SymbolSetUploadModal />
+            </>
+        </AlphaAccessScenePrompt>
     )
 }
diff --git a/frontend/src/scenes/error-tracking/ErrorTrackingScene.tsx b/frontend/src/scenes/error-tracking/ErrorTrackingScene.tsx
index 754cb398ec136..d2fb4ffc8ebb7 100644
--- a/frontend/src/scenes/error-tracking/ErrorTrackingScene.tsx
+++ b/frontend/src/scenes/error-tracking/ErrorTrackingScene.tsx
@@ -16,6 +16,7 @@ import { ErrorTrackingIssue } from '~/queries/schema'
 import { QueryContext, QueryContextColumnComponent, QueryContextColumnTitleComponent } from '~/queries/types'
 import { InsightLogicProps } from '~/types'
 
+import { AlphaAccessScenePrompt } from './AlphaAccessScenePrompt'
 import { AssigneeSelect } from './AssigneeSelect'
 import { errorTrackingDataNodeLogic } from './errorTrackingDataNodeLogic'
 import ErrorTrackingFilters from './ErrorTrackingFilters'
@@ -52,14 +53,16 @@ export function ErrorTrackingScene(): JSX.Element {
     }
 
     return (
-        <BindLogic logic={errorTrackingDataNodeLogic} props={{ query, key: insightVizDataNodeKey(insightProps) }}>
-            <Header />
-            <FeedbackNotice text="Error tracking is in closed alpha. Thanks for taking part! We'd love to hear what you think." />
-            <ErrorTrackingFilters.FilterGroup />
-            <LemonDivider className="mt-2" />
-            {selectedIssueIds.length === 0 ? <ErrorTrackingFilters.Options /> : <ErrorTrackingActions />}
-            <Query query={query} context={context} />
-        </BindLogic>
+        <AlphaAccessScenePrompt>
+            <BindLogic logic={errorTrackingDataNodeLogic} props={{ query, key: insightVizDataNodeKey(insightProps) }}>
+                <Header />
+                <FeedbackNotice text="Error tracking is in closed alpha. Thanks for taking part! We'd love to hear what you think." />
+                <ErrorTrackingFilters.FilterGroup />
+                <LemonDivider className="mt-2" />
+                {selectedIssueIds.length === 0 ? <ErrorTrackingFilters.Options /> : <ErrorTrackingActions />}
+                <Query query={query} context={context} />
+            </BindLogic>
+        </AlphaAccessScenePrompt>
     )
 }
 
diff --git a/frontend/src/scenes/error-tracking/errorTrackingLogic.ts b/frontend/src/scenes/error-tracking/errorTrackingLogic.ts
index c1a847a8ab647..260e4e4d08ccb 100644
--- a/frontend/src/scenes/error-tracking/errorTrackingLogic.ts
+++ b/frontend/src/scenes/error-tracking/errorTrackingLogic.ts
@@ -27,7 +27,9 @@ const customOptions: Record<string, SparklineOption[]> = {
     all: [lastYear, lastMonth, lastDay],
 }
 
-const DEFAULT_FILTER_GROUP = {
+export const DEFAULT_ERROR_TRACKING_DATE_RANGE = { date_from: '-7d', date_to: null }
+
+export const DEFAULT_ERROR_TRACKING_FILTER_GROUP = {
     type: FilterLogicalOperator.And,
     values: [{ type: FilterLogicalOperator.And, values: [] }],
 }
@@ -42,15 +44,15 @@ export const errorTrackingLogic = kea<errorTrackingLogicType>([
     actions({
         setDateRange: (dateRange: DateRange) => ({ dateRange }),
         setAssignee: (assignee: number | null) => ({ assignee }),
+        setSearchQuery: (searchQuery: string) => ({ searchQuery }),
         setFilterGroup: (filterGroup: UniversalFiltersGroup) => ({ filterGroup }),
         setFilterTestAccounts: (filterTestAccounts: boolean) => ({ filterTestAccounts }),
-        setSearchQuery: (searchQuery: string) => ({ searchQuery }),
         setSparklineSelectedPeriod: (period: string | null) => ({ period }),
         _setSparklineOptions: (options: SparklineOption[]) => ({ options }),
     }),
     reducers({
         dateRange: [
-            { date_from: '-7d', date_to: null } as DateRange,
+            DEFAULT_ERROR_TRACKING_DATE_RANGE as DateRange,
             { persist: true },
             {
                 setDateRange: (_, { dateRange }) => dateRange,
@@ -64,7 +66,7 @@ export const errorTrackingLogic = kea<errorTrackingLogicType>([
             },
         ],
         filterGroup: [
-            DEFAULT_FILTER_GROUP as UniversalFiltersGroup,
+            DEFAULT_ERROR_TRACKING_FILTER_GROUP as UniversalFiltersGroup,
             { persist: true },
             {
                 setFilterGroup: (_, { filterGroup }) => filterGroup,
diff --git a/frontend/src/scenes/error-tracking/errorTrackingSceneLogic.ts b/frontend/src/scenes/error-tracking/errorTrackingSceneLogic.ts
index bd36ead868256..92dbd6d61dcac 100644
--- a/frontend/src/scenes/error-tracking/errorTrackingSceneLogic.ts
+++ b/frontend/src/scenes/error-tracking/errorTrackingSceneLogic.ts
@@ -1,9 +1,17 @@
+import equal from 'fast-deep-equal'
 import { actions, connect, kea, path, reducers, selectors } from 'kea'
+import { actionToUrl, router, urlToAction } from 'kea-router'
 import { subscriptions } from 'kea-subscriptions'
+import { objectsEqual } from 'lib/utils'
+import { Params } from 'scenes/sceneTypes'
 
 import { DataTableNode, ErrorTrackingQuery } from '~/queries/schema'
 
-import { errorTrackingLogic } from './errorTrackingLogic'
+import {
+    DEFAULT_ERROR_TRACKING_DATE_RANGE,
+    DEFAULT_ERROR_TRACKING_FILTER_GROUP,
+    errorTrackingLogic,
+} from './errorTrackingLogic'
 import type { errorTrackingSceneLogicType } from './errorTrackingSceneLogicType'
 import { errorTrackingQuery } from './queries'
 
@@ -23,6 +31,10 @@ export const errorTrackingSceneLogic = kea<errorTrackingSceneLogicType>([
                 'hasGroupActions',
             ],
         ],
+        actions: [
+            errorTrackingLogic,
+            ['setAssignee', 'setDateRange', 'setFilterGroup', 'setSearchQuery', 'setFilterTestAccounts'],
+        ],
     }),
 
     actions({
@@ -86,4 +98,79 @@ export const errorTrackingSceneLogic = kea<errorTrackingSceneLogicType>([
     subscriptions(({ actions }) => ({
         query: () => actions.setSelectedIssueIds([]),
     })),
+
+    actionToUrl(({ values }) => {
+        const buildURL = (): [
+            string,
+            Params,
+            Record<string, any>,
+            {
+                replace: boolean
+            }
+        ] => {
+            const searchParams: Params = {
+                orderBy: values.orderBy,
+                filterTestAccounts: values.filterTestAccounts,
+            }
+
+            if (values.assignee) {
+                searchParams.assignee = values.assignee
+            }
+            if (values.searchQuery) {
+                searchParams.searchQuery = values.searchQuery
+            }
+            if (!objectsEqual(values.filterGroup, DEFAULT_ERROR_TRACKING_FILTER_GROUP)) {
+                searchParams.filterGroup = values.filterGroup
+            }
+            if (!objectsEqual(values.dateRange, DEFAULT_ERROR_TRACKING_DATE_RANGE)) {
+                searchParams.dateRange = values.dateRange
+            }
+
+            if (!objectsEqual(searchParams, router.values.searchParams)) {
+                return [router.values.location.pathname, searchParams, router.values.hashParams, { replace: true }]
+            }
+
+            return [
+                router.values.location.pathname,
+                router.values.searchParams,
+                router.values.hashParams,
+                { replace: false },
+            ]
+        }
+
+        return {
+            setOrderBy: () => buildURL(),
+            setAssignee: () => buildURL(),
+            setDateRange: () => buildURL(),
+            setFilterGroup: () => buildURL(),
+            setSearchQuery: () => buildURL(),
+            setFilterTestAccounts: () => buildURL(),
+        }
+    }),
+
+    urlToAction(({ actions, values }) => {
+        const urlToAction = (_: any, params: Params): void => {
+            if (params.orderBy && !equal(params.orderBy, values.orderBy)) {
+                actions.setOrderBy(params.orderBy)
+            }
+            if (params.dateRange && !equal(params.dateRange, values.dateRange)) {
+                actions.setDateRange(params.dateRange)
+            }
+            if (params.filterGroup && !equal(params.filterGroup, values.filterGroup)) {
+                actions.setFilterGroup(params.filterGroup)
+            }
+            if (params.filterTestAccounts && !equal(params.filterTestAccounts, values.filterTestAccounts)) {
+                actions.setFilterTestAccounts(params.filterTestAccounts)
+            }
+            if (params.assignee && !equal(params.assignee, values.assignee)) {
+                actions.setAssignee(params.assignee)
+            }
+            if (params.searchQuery && !equal(params.searchQuery, values.searchQuery)) {
+                actions.setSearchQuery(params.searchQuery)
+            }
+        }
+        return {
+            '*': urlToAction,
+        }
+    }),
 ])
diff --git a/frontend/src/scenes/experiments/ExperimentCodeSnippets.tsx b/frontend/src/scenes/experiments/ExperimentCodeSnippets.tsx
index d5a2abca2306f..8d9aefd7269a9 100644
--- a/frontend/src/scenes/experiments/ExperimentCodeSnippets.tsx
+++ b/frontend/src/scenes/experiments/ExperimentCodeSnippets.tsx
@@ -188,10 +188,10 @@ export function FlutterSnippet({ flagKey, variant }: SnippetProps): JSX.Element
         <>
             <CodeSnippet language={Language.Dart} wrap>
                 {`if (${clientSuffix}${flagFunction}('${flagKey}')${variantSuffix}) {
-    // Do something differently for this user
+  // Do something differently for this user
 } else {
-    // It's a good idea to let control variant always be the default behaviour,
-    // so if something goes wrong with flag evaluation, you don't break your app.
+  // It's a good idea to let control variant always be the default behaviour,
+  // so if something goes wrong with flag evaluation, you don't break your app.
 }
             `}
             </CodeSnippet>
diff --git a/frontend/src/scenes/experiments/ExperimentForm.tsx b/frontend/src/scenes/experiments/ExperimentForm.tsx
index d1fd0b140bc4d..125fb2320ddab 100644
--- a/frontend/src/scenes/experiments/ExperimentForm.tsx
+++ b/frontend/src/scenes/experiments/ExperimentForm.tsx
@@ -6,6 +6,7 @@ import { useActions, useValues } from 'kea'
 import { Form, Group } from 'kea-forms'
 import { ExperimentVariantNumber } from 'lib/components/SeriesGlyph'
 import { MAX_EXPERIMENT_VARIANTS } from 'lib/constants'
+import { groupsAccessLogic, GroupsAccessStatus } from 'lib/introductions/groupsAccessLogic'
 import { LemonButton } from 'lib/lemon-ui/LemonButton'
 import { LemonField } from 'lib/lemon-ui/LemonField'
 import { LemonRadio } from 'lib/lemon-ui/LemonRadio'
@@ -20,6 +21,7 @@ const ExperimentFormFields = (): JSX.Element => {
     const { addExperimentGroup, removeExperimentGroup, setExperiment, createExperiment, setExperimentType } =
         useActions(experimentLogic)
     const { webExperimentsAvailable } = useValues(experimentsLogic)
+    const { groupsAccessStatus } = useValues(groupsAccessLogic)
 
     return (
         <div>
@@ -103,37 +105,40 @@ const ExperimentFormFields = (): JSX.Element => {
                         />
                     </div>
                 )}
-                <div>
-                    <h3 className="mt-10">Participant type</h3>
-                    <div className="text-xs text-muted">
-                        The type on which to aggregate metrics. You can change this at any time during the experiment.
-                    </div>
-                    <LemonDivider />
-                    <LemonRadio
-                        value={
-                            experiment.parameters.aggregation_group_type_index != undefined
-                                ? experiment.parameters.aggregation_group_type_index
-                                : -1
-                        }
-                        onChange={(rawGroupTypeIndex) => {
-                            const groupTypeIndex = rawGroupTypeIndex !== -1 ? rawGroupTypeIndex : undefined
+                {groupsAccessStatus === GroupsAccessStatus.AlreadyUsing && (
+                    <div>
+                        <h3 className="mt-10">Participant type</h3>
+                        <div className="text-xs text-muted">
+                            The type on which to aggregate metrics. You can change this at any time during the
+                            experiment.
+                        </div>
+                        <LemonDivider />
+                        <LemonRadio
+                            value={
+                                experiment.parameters.aggregation_group_type_index != undefined
+                                    ? experiment.parameters.aggregation_group_type_index
+                                    : -1
+                            }
+                            onChange={(rawGroupTypeIndex) => {
+                                const groupTypeIndex = rawGroupTypeIndex !== -1 ? rawGroupTypeIndex : undefined
 
-                            setExperiment({
-                                parameters: {
-                                    ...experiment.parameters,
-                                    aggregation_group_type_index: groupTypeIndex ?? undefined,
-                                },
-                            })
-                        }}
-                        options={[
-                            { value: -1, label: 'Persons' },
-                            ...Array.from(groupTypes.values()).map((groupType) => ({
-                                value: groupType.group_type_index,
-                                label: capitalizeFirstLetter(aggregationLabel(groupType.group_type_index).plural),
-                            })),
-                        ]}
-                    />
-                </div>
+                                setExperiment({
+                                    parameters: {
+                                        ...experiment.parameters,
+                                        aggregation_group_type_index: groupTypeIndex ?? undefined,
+                                    },
+                                })
+                            }}
+                            options={[
+                                { value: -1, label: 'Persons' },
+                                ...Array.from(groupTypes.values()).map((groupType) => ({
+                                    value: groupType.group_type_index,
+                                    label: capitalizeFirstLetter(aggregationLabel(groupType.group_type_index).plural),
+                                })),
+                            ]}
+                        />
+                    </div>
+                )}
                 <div className="mt-10">
                     <h3 className="mb-1">Variants</h3>
                     <div className="text-xs text-muted">Add up to 9 variants to test against your control.</div>
diff --git a/frontend/src/scenes/experiments/ExperimentView/CumulativeExposuresChart.tsx b/frontend/src/scenes/experiments/ExperimentView/CumulativeExposuresChart.tsx
index 575eb84c52708..7f4378a7ec5ef 100644
--- a/frontend/src/scenes/experiments/ExperimentView/CumulativeExposuresChart.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/CumulativeExposuresChart.tsx
@@ -1,28 +1,16 @@
 import { IconInfo } from '@posthog/icons'
 import { Tooltip } from '@posthog/lemon-ui'
 import { useValues } from 'kea'
-import { FEATURE_FLAGS } from 'lib/constants'
-import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { InsightEmptyState } from 'scenes/insights/EmptyStates'
 
 import { InsightViz } from '~/queries/nodes/InsightViz/InsightViz'
-import { queryFromFilters } from '~/queries/nodes/InsightViz/utils'
 import { CachedExperimentTrendsQueryResponse, InsightQueryNode, InsightVizNode, NodeKind } from '~/queries/schema'
-import {
-    _TrendsExperimentResults,
-    BaseMathType,
-    ChartDisplayType,
-    InsightType,
-    PropertyFilterType,
-    PropertyOperator,
-} from '~/types'
+import { BaseMathType, ChartDisplayType, InsightType, PropertyFilterType, PropertyOperator } from '~/types'
 
 import { experimentLogic } from '../experimentLogic'
-import { transformResultFilters } from '../utils'
 
 export function CumulativeExposuresChart(): JSX.Element {
     const { experiment, experimentResults, getMetricType } = useValues(experimentLogic)
-    const { featureFlags } = useValues(featureFlagLogic)
 
     const metricIdx = 0
     const metricType = getMetricType(metricIdx)
@@ -32,99 +20,52 @@ export function CumulativeExposuresChart(): JSX.Element {
         variants.push(`holdout-${experiment.holdout.id}`)
     }
 
-    let query
+    let query: InsightVizNode<InsightQueryNode>
 
-    // :FLAG: CLEAN UP AFTER MIGRATION
-    if (featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL]) {
-        if (metricType === InsightType.TRENDS) {
-            query = {
-                kind: NodeKind.InsightVizNode,
-                source: (experimentResults as CachedExperimentTrendsQueryResponse).exposure_query,
-            }
-        } else {
-            query = {
-                kind: NodeKind.InsightVizNode,
-                source: {
-                    kind: NodeKind.TrendsQuery,
-                    dateRange: {
-                        date_from: experiment.start_date,
-                        date_to: experiment.end_date,
-                    },
-                    interval: 'day',
-                    trendsFilter: {
-                        display: ChartDisplayType.ActionsLineGraphCumulative,
-                        showLegend: false,
-                        smoothingIntervals: 1,
-                    },
-                    series: [
-                        {
-                            kind: NodeKind.EventsNode,
-                            event: experiment.filters?.events?.[0]?.name,
-                            math: BaseMathType.UniqueUsers,
-                            properties: [
-                                {
-                                    key: `$feature/${experiment.feature_flag_key}`,
-                                    value: variants,
-                                    operator: PropertyOperator.Exact,
-                                    type: PropertyFilterType.Event,
-                                },
-                            ],
-                        },
-                    ],
-                    breakdownFilter: {
-                        breakdown: `$feature/${experiment.feature_flag_key}`,
-                        breakdown_type: 'event',
-                    },
-                },
-            }
+    if (metricType === InsightType.TRENDS) {
+        query = {
+            kind: NodeKind.InsightVizNode,
+            source: (experimentResults as CachedExperimentTrendsQueryResponse)?.exposure_query || {
+                kind: NodeKind.TrendsQuery,
+                series: [],
+                interval: 'day',
+            },
         }
     } else {
-        if (metricType === InsightType.TRENDS && experiment.parameters?.custom_exposure_filter) {
-            const trendResults = experimentResults as _TrendsExperimentResults
-            const queryFilters = {
-                ...trendResults.exposure_filters,
-                display: ChartDisplayType.ActionsLineGraphCumulative,
-            } as _TrendsExperimentResults['exposure_filters']
-            query = queryFromFilters(transformResultFilters(queryFilters))
-        } else {
-            query = {
-                kind: NodeKind.InsightVizNode,
-                source: {
-                    kind: NodeKind.TrendsQuery,
-                    dateRange: {
-                        date_from: experiment.start_date,
-                        date_to: experiment.end_date,
-                    },
-                    interval: 'day',
-                    trendsFilter: {
-                        display: ChartDisplayType.ActionsLineGraphCumulative,
-                        showLegend: false,
-                        smoothingIntervals: 1,
-                    },
-                    series: [
-                        {
-                            kind: NodeKind.EventsNode,
-                            event:
-                                metricType === InsightType.TRENDS
-                                    ? '$feature_flag_called'
-                                    : experiment.filters?.events?.[0]?.name,
-                            math: BaseMathType.UniqueUsers,
-                            properties: [
-                                {
-                                    key: `$feature/${experiment.feature_flag_key}`,
-                                    value: variants,
-                                    operator: PropertyOperator.Exact,
-                                    type: PropertyFilterType.Event,
-                                },
-                            ],
-                        },
-                    ],
-                    breakdownFilter: {
-                        breakdown: `$feature/${experiment.feature_flag_key}`,
-                        breakdown_type: 'event',
+        query = {
+            kind: NodeKind.InsightVizNode,
+            source: {
+                kind: NodeKind.TrendsQuery,
+                dateRange: {
+                    date_from: experiment.start_date,
+                    date_to: experiment.end_date,
+                },
+                interval: 'day',
+                trendsFilter: {
+                    display: ChartDisplayType.ActionsLineGraphCumulative,
+                    showLegend: false,
+                    smoothingIntervals: 1,
+                },
+                series: [
+                    {
+                        kind: NodeKind.EventsNode,
+                        event: experiment.filters?.events?.[0]?.name,
+                        math: BaseMathType.UniqueUsers,
+                        properties: [
+                            {
+                                key: `$feature/${experiment.feature_flag_key}`,
+                                value: variants,
+                                operator: PropertyOperator.Exact,
+                                type: PropertyFilterType.Event,
+                            },
+                        ],
                     },
+                ],
+                breakdownFilter: {
+                    breakdown: `$feature/${experiment.feature_flag_key}`,
+                    breakdown_type: 'event',
                 },
-            }
+            },
         }
     }
 
@@ -139,7 +80,7 @@ export function CumulativeExposuresChart(): JSX.Element {
             {experiment.start_date ? (
                 <InsightViz
                     query={{
-                        ...(query as InsightVizNode<InsightQueryNode>),
+                        ...query,
                         showTable: true,
                     }}
                     setQuery={() => {}}
diff --git a/frontend/src/scenes/experiments/ExperimentView/DataCollectionCalculator.tsx b/frontend/src/scenes/experiments/ExperimentView/DataCollectionCalculator.tsx
index 95938242c143d..e7797f03de7ba 100644
--- a/frontend/src/scenes/experiments/ExperimentView/DataCollectionCalculator.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/DataCollectionCalculator.tsx
@@ -3,10 +3,10 @@ import { LemonBanner, LemonInput, Link, Tooltip } from '@posthog/lemon-ui'
 import { BindLogic, useActions, useValues } from 'kea'
 import { LemonSlider } from 'lib/lemon-ui/LemonSlider'
 import { humanFriendlyNumber } from 'lib/utils'
-import { insightDataLogic } from 'scenes/insights/insightDataLogic'
 import { insightLogic } from 'scenes/insights/insightLogic'
 
 import { Query } from '~/queries/Query/Query'
+import { ExperimentFunnelsQuery, ExperimentTrendsQuery, NodeKind } from '~/queries/schema'
 import { ExperimentIdType, InsightType } from '~/types'
 
 import { MetricInsightId } from '../constants'
@@ -120,7 +120,16 @@ export function DataCollectionCalculator({ experimentId }: ExperimentCalculatorP
         syncWithUrl: false,
     })
     const { insightProps } = useValues(insightLogicInstance)
-    const { query } = useValues(insightDataLogic(insightProps))
+    let query = null
+    if (experiment.metrics.length > 0) {
+        query = {
+            kind: NodeKind.InsightVizNode,
+            source:
+                metricType === InsightType.FUNNELS
+                    ? (experiment.metrics[0] as ExperimentFunnelsQuery).funnels_query
+                    : (experiment.metrics[0] as ExperimentTrendsQuery).count_query,
+        }
+    }
 
     const funnelConversionRate = conversionMetrics?.totalRate * 100 || 0
 
diff --git a/frontend/src/scenes/experiments/ExperimentView/DistributionTable.tsx b/frontend/src/scenes/experiments/ExperimentView/DistributionTable.tsx
index 30d6b93ea8278..5ebf192769a2d 100644
--- a/frontend/src/scenes/experiments/ExperimentView/DistributionTable.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/DistributionTable.tsx
@@ -64,7 +64,12 @@ export function DistributionModal({ experimentId }: { experimentId: Experiment['
                     <LemonButton
                         onClick={() => {
                             saveSidebarExperimentFeatureFlag(featureFlag)
-                            updateExperiment({ holdout_id: experiment.holdout_id })
+                            updateExperiment({
+                                holdout_id: experiment.holdout_id,
+                                parameters: {
+                                    feature_flag_variants: featureFlag?.filters?.multivariate?.variants ?? [],
+                                },
+                            })
                             closeDistributionModal()
                         }}
                         type="primary"
diff --git a/frontend/src/scenes/experiments/ExperimentView/Goal.tsx b/frontend/src/scenes/experiments/ExperimentView/Goal.tsx
index 867d82bc83a37..59766e480529f 100644
--- a/frontend/src/scenes/experiments/ExperimentView/Goal.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/Goal.tsx
@@ -250,6 +250,12 @@ export function Goal(): JSX.Element {
     const [isModalOpen, setIsModalOpen] = useState(false)
     const metricType = getMetricType(0)
 
+    // :FLAG: CLEAN UP AFTER MIGRATION
+    const isDataWarehouseMetric =
+        featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL] &&
+        metricType === InsightType.TRENDS &&
+        (experiment.metrics[0] as ExperimentTrendsQuery).count_query?.series[0].kind === NodeKind.DataWarehouseNode
+
     return (
         <div>
             <div>
@@ -322,16 +328,18 @@ export function Goal(): JSX.Element {
                             Change goal
                         </LemonButton>
                     </div>
-                    {metricType === InsightType.TRENDS && !experimentMathAggregationForTrends() && (
-                        <>
-                            <LemonDivider className="" vertical />
-                            <div className="">
-                                <div className="mt-auto ml-auto">
-                                    <ExposureMetric experimentId={experimentId} />
+                    {metricType === InsightType.TRENDS &&
+                        !experimentMathAggregationForTrends() &&
+                        !isDataWarehouseMetric && (
+                            <>
+                                <LemonDivider className="" vertical />
+                                <div className="">
+                                    <div className="mt-auto ml-auto">
+                                        <ExposureMetric experimentId={experimentId} />
+                                    </div>
                                 </div>
-                            </div>
-                        </>
-                    )}
+                            </>
+                        )}
                 </div>
             )}
             <PrimaryMetricModal
diff --git a/frontend/src/scenes/experiments/ExperimentView/SecondaryMetricsTable.tsx b/frontend/src/scenes/experiments/ExperimentView/SecondaryMetricsTable.tsx
index 40a1e8133be54..5474962ec738b 100644
--- a/frontend/src/scenes/experiments/ExperimentView/SecondaryMetricsTable.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/SecondaryMetricsTable.tsx
@@ -2,19 +2,13 @@ import { IconInfo, IconPencil, IconPlus } from '@posthog/icons'
 import { LemonButton, LemonTable, LemonTableColumns, Tooltip } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { EntityFilterInfo } from 'lib/components/EntityFilterInfo'
-import { FEATURE_FLAGS } from 'lib/constants'
 import { IconAreaChart } from 'lib/lemon-ui/icons'
-import { capitalizeFirstLetter } from 'lib/utils'
+import { capitalizeFirstLetter, humanFriendlyNumber } from 'lib/utils'
 import { useState } from 'react'
 
 import { Experiment, InsightType } from '~/types'
 
-import {
-    experimentLogic,
-    getDefaultFilters,
-    getDefaultFunnelsMetric,
-    TabularSecondaryMetricResults,
-} from '../experimentLogic'
+import { experimentLogic, getDefaultFunnelsMetric, TabularSecondaryMetricResults } from '../experimentLogic'
 import { SecondaryMetricChartModal } from '../Metrics/SecondaryMetricChartModal'
 import { SecondaryMetricModal } from '../Metrics/SecondaryMetricModal'
 import { VariantTag } from './components'
@@ -39,7 +33,6 @@ export function SecondaryMetricsTable({ experimentId }: { experimentId: Experime
         credibleIntervalForVariant,
         experimentMathAggregationForTrends,
         getHighestProbabilityVariant,
-        featureFlags,
     } = useValues(experimentLogic({ experimentId }))
     const { loadExperiment } = useActions(experimentLogic({ experimentId }))
 
@@ -64,13 +57,7 @@ export function SecondaryMetricsTable({ experimentId }: { experimentId: Experime
         setModalMetricIdx(null)
     }
 
-    // :FLAG: CLEAN UP AFTER MIGRATION
-    let metrics
-    if (featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL]) {
-        metrics = experiment.metrics_secondary
-    } else {
-        metrics = experiment.secondary_metrics
-    }
+    const metrics = experiment.metrics_secondary
 
     const columns: LemonTableColumns<any> = [
         {
@@ -149,16 +136,18 @@ export function SecondaryMetricsTable({ experimentId }: { experimentId: Experime
                         ),
                         render: function Key(_, item: TabularSecondaryMetricResults): JSX.Element {
                             const { variant } = item
-                            return <div>{targetResults ? countDataForVariant(targetResults, variant) : '—'}</div>
+                            const count = targetResults ? countDataForVariant(targetResults, variant) : null
+                            return <div>{count === null ? '—' : humanFriendlyNumber(count)}</div>
                         },
                     },
                     {
                         title: 'Exposure',
                         render: function Key(_, item: TabularSecondaryMetricResults): JSX.Element {
                             const { variant } = item
-                            return (
-                                <div>{targetResults ? exposureCountDataForVariant(targetResults, variant) : '—'}</div>
-                            )
+                            const exposureCount = targetResults
+                                ? exposureCountDataForVariant(targetResults, variant)
+                                : null
+                            return <div>{exposureCount === null ? '—' : humanFriendlyNumber(exposureCount)}</div>
                         },
                     },
                     {
@@ -337,7 +326,7 @@ const AddSecondaryMetricButton = ({
     metrics: any
     openEditModal: (metricIdx: number) => void
 }): JSX.Element => {
-    const { experiment, featureFlags } = useValues(experimentLogic({ experimentId }))
+    const { experiment } = useValues(experimentLogic({ experimentId }))
     const { setExperiment } = useActions(experimentLogic({ experimentId }))
     return (
         <LemonButton
@@ -345,26 +334,11 @@ const AddSecondaryMetricButton = ({
             type="secondary"
             size="small"
             onClick={() => {
-                // :FLAG: CLEAN UP AFTER MIGRATION
-                if (featureFlags[FEATURE_FLAGS.EXPERIMENTS_HOGQL]) {
-                    const newMetricsSecondary = [...experiment.metrics_secondary, getDefaultFunnelsMetric()]
-                    setExperiment({
-                        metrics_secondary: newMetricsSecondary,
-                    })
-                    openEditModal(newMetricsSecondary.length - 1)
-                } else {
-                    const newSecondaryMetrics = [
-                        ...experiment.secondary_metrics,
-                        {
-                            name: '',
-                            filters: getDefaultFilters(InsightType.FUNNELS, undefined),
-                        },
-                    ]
-                    setExperiment({
-                        secondary_metrics: newSecondaryMetrics,
-                    })
-                    openEditModal(newSecondaryMetrics.length - 1)
-                }
+                const newMetricsSecondary = [...experiment.metrics_secondary, getDefaultFunnelsMetric()]
+                setExperiment({
+                    metrics_secondary: newMetricsSecondary,
+                })
+                openEditModal(newMetricsSecondary.length - 1)
             }}
             disabledReason={
                 metrics.length >= MAX_SECONDARY_METRICS
diff --git a/frontend/src/scenes/experiments/ExperimentView/SummaryTable.tsx b/frontend/src/scenes/experiments/ExperimentView/SummaryTable.tsx
index b859dae72e071..4ba16ded0e86c 100644
--- a/frontend/src/scenes/experiments/ExperimentView/SummaryTable.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/SummaryTable.tsx
@@ -323,6 +323,13 @@ export function SummaryTable(): JSX.Element {
                                 ],
                             },
                         ]
+                        if (experiment.filters.insight === InsightType.FUNNELS) {
+                            if (experiment.filters?.events?.[0]) {
+                                filters.push(experiment.filters.events[0])
+                            } else if (experiment.filters?.actions?.[0]) {
+                                filters.push(experiment.filters.actions[0])
+                            }
+                        }
                         const filterGroup: Partial<RecordingUniversalFilters> = {
                             filter_group: {
                                 type: FilterLogicalOperator.And,
diff --git a/frontend/src/scenes/experiments/ExperimentView/components.tsx b/frontend/src/scenes/experiments/ExperimentView/components.tsx
index c24376ac7e67c..df8580fee68dd 100644
--- a/frontend/src/scenes/experiments/ExperimentView/components.tsx
+++ b/frontend/src/scenes/experiments/ExperimentView/components.tsx
@@ -493,44 +493,38 @@ export function PageHeaderCustom(): JSX.Element {
                     )}
                     {experiment && isExperimentRunning && (
                         <div className="flex flex-row gap-2">
-                            {!isExperimentStopped && !experiment.archived && (
-                                <>
-                                    <More
-                                        overlay={
-                                            <>
-                                                <LemonButton
-                                                    onClick={() =>
-                                                        exposureCohortId ? undefined : createExposureCohort()
-                                                    }
-                                                    fullWidth
-                                                    data-attr={`${
-                                                        exposureCohortId ? 'view' : 'create'
-                                                    }-exposure-cohort`}
-                                                    to={exposureCohortId ? urls.cohort(exposureCohortId) : undefined}
-                                                    targetBlank={!!exposureCohortId}
-                                                >
-                                                    {exposureCohortId ? 'View' : 'Create'} exposure cohort
-                                                </LemonButton>
-                                                <LemonButton
-                                                    onClick={() => loadExperimentResults(true)}
-                                                    fullWidth
-                                                    data-attr="refresh-experiment"
-                                                >
-                                                    Refresh experiment results
-                                                </LemonButton>
-                                                <LemonButton
-                                                    onClick={() => loadSecondaryMetricResults(true)}
-                                                    fullWidth
-                                                    data-attr="refresh-secondary-metrics"
-                                                >
-                                                    Refresh secondary metrics
-                                                </LemonButton>
-                                            </>
-                                        }
-                                    />
-                                    <LemonDivider vertical />
-                                </>
-                            )}
+                            <>
+                                <More
+                                    overlay={
+                                        <>
+                                            <LemonButton
+                                                onClick={() => (exposureCohortId ? undefined : createExposureCohort())}
+                                                fullWidth
+                                                data-attr={`${exposureCohortId ? 'view' : 'create'}-exposure-cohort`}
+                                                to={exposureCohortId ? urls.cohort(exposureCohortId) : undefined}
+                                                targetBlank={!!exposureCohortId}
+                                            >
+                                                {exposureCohortId ? 'View' : 'Create'} exposure cohort
+                                            </LemonButton>
+                                            <LemonButton
+                                                onClick={() => loadExperimentResults(true)}
+                                                fullWidth
+                                                data-attr="refresh-experiment"
+                                            >
+                                                Refresh experiment results
+                                            </LemonButton>
+                                            <LemonButton
+                                                onClick={() => loadSecondaryMetricResults(true)}
+                                                fullWidth
+                                                data-attr="refresh-secondary-metrics"
+                                            >
+                                                Refresh secondary metrics
+                                            </LemonButton>
+                                        </>
+                                    }
+                                />
+                                <LemonDivider vertical />
+                            </>
                             <ResetButton experimentId={experiment.id} />
                             {!experiment.end_date && (
                                 <LemonButton
diff --git a/frontend/src/scenes/experiments/Metrics/PrimaryGoalFunnels.tsx b/frontend/src/scenes/experiments/Metrics/PrimaryGoalFunnels.tsx
index aefca698f5ad7..50468541a0d9b 100644
--- a/frontend/src/scenes/experiments/Metrics/PrimaryGoalFunnels.tsx
+++ b/frontend/src/scenes/experiments/Metrics/PrimaryGoalFunnels.tsx
@@ -1,6 +1,7 @@
 import { LemonLabel } from '@posthog/lemon-ui'
 import { LemonInput } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
+import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
 import { TestAccountFilterSwitch } from 'lib/components/TestAccountFiltersSwitch'
 import { EXPERIMENT_DEFAULT_DURATION, FEATURE_FLAGS } from 'lib/constants'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
@@ -31,6 +32,12 @@ export function PrimaryGoalFunnels(): JSX.Element {
     const metricIdx = 0
     const currentMetric = experiment.metrics[metricIdx] as ExperimentFunnelsQuery
 
+    const actionFilterProps = {
+        ...commonActionFilterProps,
+        // Remove data warehouse from the list because it's not supported in experiments
+        actionsTaxonomicGroupTypes: [TaxonomicFilterGroupType.Events, TaxonomicFilterGroupType.Actions],
+    }
+
     return (
         <>
             <div className="mb-4">
@@ -107,7 +114,7 @@ export function PrimaryGoalFunnels(): JSX.Element {
                 seriesIndicatorType="numeric"
                 sortable={true}
                 showNestedArrow={true}
-                {...commonActionFilterProps}
+                {...actionFilterProps}
             />
             <div className="mt-4 space-y-4">
                 <FunnelAggregationSelect
diff --git a/frontend/src/scenes/experiments/experimentLogic.tsx b/frontend/src/scenes/experiments/experimentLogic.tsx
index f7340dc2a9aae..88d57b134e0d3 100644
--- a/frontend/src/scenes/experiments/experimentLogic.tsx
+++ b/frontend/src/scenes/experiments/experimentLogic.tsx
@@ -20,6 +20,7 @@ import { cleanFilters, getDefaultEvent } from 'scenes/insights/utils/cleanFilter
 import { projectLogic } from 'scenes/projectLogic'
 import { sceneLogic } from 'scenes/sceneLogic'
 import { Scene } from 'scenes/sceneTypes'
+import { teamLogic } from 'scenes/teamLogic'
 import { trendsDataLogic } from 'scenes/trends/trendsDataLogic'
 import { urls } from 'scenes/urls'
 
@@ -51,6 +52,7 @@ import {
     FunnelVizType,
     InsightType,
     MultivariateFlagVariant,
+    ProductKey,
     PropertyMathType,
     SecondaryMetricResults,
     SignificanceCode,
@@ -164,6 +166,8 @@ export const experimentLogic = kea<experimentLogicType>([
                 'reportExperimentReleaseConditionsViewed',
                 'reportExperimentHoldoutAssigned',
             ],
+            teamLogic,
+            ['addProductIntent'],
         ],
     })),
     actions({
@@ -534,7 +538,10 @@ export const experimentLogic = kea<experimentLogicType>([
                         },
                         ...(!draft && { start_date: dayjs() }),
                     })
-                    response && actions.reportExperimentCreated(response)
+                    if (response) {
+                        actions.reportExperimentCreated(response)
+                        actions.addProductIntent({ product_type: ProductKey.EXPERIMENTS })
+                    }
                 }
             } catch (error: any) {
                 lemonToast.error(error.detail || 'Failed to create experiment')
@@ -822,6 +829,12 @@ export const experimentLogic = kea<experimentLogicType>([
                                 ...values.experiment.metrics[0],
                                 experiment_id: values.experimentId,
                             }
+                            if (
+                                queryWithExperimentId.kind === NodeKind.ExperimentTrendsQuery &&
+                                values.featureFlags[FEATURE_FLAGS.EXPERIMENT_STATS_V2]
+                            ) {
+                                queryWithExperimentId.stats_version = 2
+                            }
 
                             const response = await performQuery(queryWithExperimentId, undefined, refresh)
 
diff --git a/frontend/src/scenes/feature-flags/FeatureFlag.tsx b/frontend/src/scenes/feature-flags/FeatureFlag.tsx
index f673e27c4b401..d7e2ad01c9133 100644
--- a/frontend/src/scenes/feature-flags/FeatureFlag.tsx
+++ b/frontend/src/scenes/feature-flags/FeatureFlag.tsx
@@ -70,6 +70,7 @@ import FeatureFlagProjects from './FeatureFlagProjects'
 import { FeatureFlagReleaseConditions } from './FeatureFlagReleaseConditions'
 import FeatureFlagSchedule from './FeatureFlagSchedule'
 import { featureFlagsLogic, FeatureFlagsTab } from './featureFlagsLogic'
+import { FeatureFlagStatusIndicator } from './FeatureFlagStatusIndicator'
 import { RecentFeatureFlagInsights } from './RecentFeatureFlagInsightsCard'
 
 export const scene: SceneExport = {
@@ -382,7 +383,8 @@ export function FeatureFlag({ id }: { id?: string } = {}): JSX.Element {
                                             <div className="text-muted text-sm pl-7">
                                                 If your feature flag is applied before identifying the user, use this to
                                                 ensure that the flag value remains consistent for the same user.
-                                                Depending on your setup, this option might not always be suitable.{' '}
+                                                Depending on your setup, this option might not always be suitable. This
+                                                feature requires creating profiles for anonymous users.{' '}
                                                 <Link
                                                     to="https://posthog.com/docs/feature-flags/creating-feature-flags#persisting-feature-flags-across-authentication-steps"
                                                     target="_blank"
@@ -734,6 +736,7 @@ function FeatureFlagRollout({ readOnly }: { readOnly?: boolean }): JSX.Element {
         aggregationTargetName,
         featureFlag,
         recordingFilterForFlag,
+        flagStatus,
     } = useValues(featureFlagLogic)
     const {
         distributeVariantsEqually,
@@ -788,38 +791,41 @@ function FeatureFlagRollout({ readOnly }: { readOnly?: boolean }): JSX.Element {
                                         Deleted
                                     </LemonTag>
                                 ) : (
-                                    <LemonSwitch
-                                        onChange={(newValue) => {
-                                            LemonDialog.open({
-                                                title: `${newValue === true ? 'Enable' : 'Disable'} this flag?`,
-                                                description: `This flag will be immediately ${
-                                                    newValue === true ? 'rolled out to' : 'rolled back from'
-                                                } the users matching the release conditions.`,
-                                                primaryButton: {
-                                                    children: 'Confirm',
-                                                    type: 'primary',
-                                                    onClick: () => {
-                                                        const updatedFlag = { ...featureFlag, active: newValue }
-                                                        setFeatureFlag(updatedFlag)
-                                                        saveFeatureFlag(updatedFlag)
+                                    <div className="flex gap-2">
+                                        <LemonSwitch
+                                            onChange={(newValue) => {
+                                                LemonDialog.open({
+                                                    title: `${newValue === true ? 'Enable' : 'Disable'} this flag?`,
+                                                    description: `This flag will be immediately ${
+                                                        newValue === true ? 'rolled out to' : 'rolled back from'
+                                                    } the users matching the release conditions.`,
+                                                    primaryButton: {
+                                                        children: 'Confirm',
+                                                        type: 'primary',
+                                                        onClick: () => {
+                                                            const updatedFlag = { ...featureFlag, active: newValue }
+                                                            setFeatureFlag(updatedFlag)
+                                                            saveFeatureFlag(updatedFlag)
+                                                        },
+                                                        size: 'small',
                                                     },
-                                                    size: 'small',
-                                                },
-                                                secondaryButton: {
-                                                    children: 'Cancel',
-                                                    type: 'tertiary',
-                                                    size: 'small',
-                                                },
-                                            })
-                                        }}
-                                        label="Enabled"
-                                        disabledReason={
-                                            !featureFlag.can_edit
-                                                ? "You only have view access to this feature flag. To make changes, contact the flag's creator."
-                                                : null
-                                        }
-                                        checked={featureFlag.active}
-                                    />
+                                                    secondaryButton: {
+                                                        children: 'Cancel',
+                                                        type: 'tertiary',
+                                                        size: 'small',
+                                                    },
+                                                })
+                                            }}
+                                            label="Enabled"
+                                            disabledReason={
+                                                !featureFlag.can_edit
+                                                    ? "You only have view access to this feature flag. To make changes, contact the flag's creator."
+                                                    : null
+                                            }
+                                            checked={featureFlag.active}
+                                        />
+                                        <FeatureFlagStatusIndicator flagStatus={flagStatus} />
+                                    </div>
                                 )}
                             </div>
                             <div className="col-span-6">
diff --git a/frontend/src/scenes/feature-flags/FeatureFlagCodeInstructions.stories.tsx b/frontend/src/scenes/feature-flags/FeatureFlagCodeInstructions.stories.tsx
index 0c5bc5df8edff..2878e8887e4c8 100644
--- a/frontend/src/scenes/feature-flags/FeatureFlagCodeInstructions.stories.tsx
+++ b/frontend/src/scenes/feature-flags/FeatureFlagCodeInstructions.stories.tsx
@@ -29,6 +29,7 @@ const REGULAR_FEATURE_FLAG: FeatureFlagType = {
     rollback_conditions: [],
     performed_rollback: false,
     can_edit: true,
+    user_access_level: 'editor',
     tags: [],
     surveys: [],
 }
diff --git a/frontend/src/scenes/feature-flags/FeatureFlagSnippets.tsx b/frontend/src/scenes/feature-flags/FeatureFlagSnippets.tsx
index dd8ebd131cefb..384283704aa07 100644
--- a/frontend/src/scenes/feature-flags/FeatureFlagSnippets.tsx
+++ b/frontend/src/scenes/feature-flags/FeatureFlagSnippets.tsx
@@ -365,7 +365,7 @@ export function FlutterSnippet({ flagKey, multivariant, payload }: FeatureFlagSn
     return (
         <CodeSnippet language={Language.Dart} wrap>
             {`if (${clientSuffix}${flagFunction}('${flagKey}')${variantSuffix}) {
-    // do something
+  // do something
 }
             `}
         </CodeSnippet>
diff --git a/frontend/src/scenes/feature-flags/FeatureFlagStatusIndicator.tsx b/frontend/src/scenes/feature-flags/FeatureFlagStatusIndicator.tsx
new file mode 100644
index 0000000000000..7b2ee5fc7fa14
--- /dev/null
+++ b/frontend/src/scenes/feature-flags/FeatureFlagStatusIndicator.tsx
@@ -0,0 +1,45 @@
+import { LemonTag } from 'lib/lemon-ui/LemonTag'
+import { Tooltip } from 'lib/lemon-ui/Tooltip'
+
+import { FeatureFlagStatus, FeatureFlagStatusResponse } from '~/types'
+
+export function FeatureFlagStatusIndicator({
+    flagStatus,
+}: {
+    flagStatus: FeatureFlagStatusResponse | null
+}): JSX.Element | null {
+    if (
+        !flagStatus ||
+        [
+            FeatureFlagStatus.ACTIVE,
+            FeatureFlagStatus.INACTIVE,
+            FeatureFlagStatus.DELETED,
+            FeatureFlagStatus.UNKNOWN,
+        ].includes(flagStatus.status)
+    ) {
+        return null
+    }
+
+    return (
+        <Tooltip
+            title={
+                <>
+                    <div className="text-sm">{flagStatus.reason}</div>
+                    <div className="text-xs">
+                        {flagStatus.status === FeatureFlagStatus.STALE &&
+                            'Make sure to remove any references to this flag in your code before deleting it.'}
+                        {flagStatus.status === FeatureFlagStatus.INACTIVE &&
+                            'It is probably not being used in your code, but be sure to remove any references to this flag before deleting it.'}
+                    </div>
+                </>
+            }
+            placement="right"
+        >
+            <span>
+                <LemonTag type="warning" className="uppercase cursor-default">
+                    {flagStatus.status}
+                </LemonTag>
+            </span>
+        </Tooltip>
+    )
+}
diff --git a/frontend/src/scenes/feature-flags/FeatureFlags.stories.tsx b/frontend/src/scenes/feature-flags/FeatureFlags.stories.tsx
index acf32b9788ed5..b929e2d203f19 100644
--- a/frontend/src/scenes/feature-flags/FeatureFlags.stories.tsx
+++ b/frontend/src/scenes/feature-flags/FeatureFlags.stories.tsx
@@ -9,6 +9,7 @@ import { mswDecorator } from '~/mocks/browser'
 import featureFlags from './__mocks__/feature_flags.json'
 
 const meta: Meta = {
+    tags: ['ff'],
     title: 'Scenes-App/Feature Flags',
     parameters: {
         layout: 'fullscreen',
@@ -33,6 +34,13 @@ const meta: Meta = {
                     200,
                     featureFlags.results.find((r) => r.id === Number(req.params['flagId'])),
                 ],
+                '/api/projects/:team_id/feature_flags/:flagId/status': () => [
+                    200,
+                    {
+                        status: 'active',
+                        reason: 'Feature flag is active',
+                    },
+                ],
             },
             post: {
                 '/api/environments/:team_id/query': {},
diff --git a/frontend/src/scenes/feature-flags/FeatureManagement.tsx b/frontend/src/scenes/feature-flags/FeatureManagement.tsx
new file mode 100644
index 0000000000000..d2d67c7286886
--- /dev/null
+++ b/frontend/src/scenes/feature-flags/FeatureManagement.tsx
@@ -0,0 +1,38 @@
+import { useActions, useValues } from 'kea'
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { SceneExport } from 'scenes/sceneTypes'
+
+import { FeatureManagementDetail } from './FeatureManagementDetail'
+import { featureManagementLogic } from './featureManagementLogic'
+
+export const scene: SceneExport = {
+    component: FeatureManagement,
+    logic: featureManagementLogic,
+}
+
+export function FeatureManagement(): JSX.Element {
+    const { activeFeatureId, features } = useValues(featureManagementLogic)
+    const { setActiveFeatureId } = useActions(featureManagementLogic)
+
+    return (
+        <div className="flex gap-4">
+            <ul className="w-1/6 space-y-px">
+                {features.results.map((feature) => (
+                    <li key={feature.id}>
+                        <LemonButton
+                            onClick={() => setActiveFeatureId(feature.id)}
+                            size="small"
+                            fullWidth
+                            active={activeFeatureId === feature.id}
+                        >
+                            <span className="truncate">{feature.name}</span>
+                        </LemonButton>
+                    </li>
+                ))}
+            </ul>
+            <div className="w-5/6">
+                <FeatureManagementDetail />
+            </div>
+        </div>
+    )
+}
diff --git a/frontend/src/scenes/feature-flags/FeatureManagementDetail.tsx b/frontend/src/scenes/feature-flags/FeatureManagementDetail.tsx
new file mode 100644
index 0000000000000..73c5776094983
--- /dev/null
+++ b/frontend/src/scenes/feature-flags/FeatureManagementDetail.tsx
@@ -0,0 +1,86 @@
+import { LemonSkeleton } from '@posthog/lemon-ui'
+import { useValues } from 'kea'
+
+import { featureManagementDetailLogic } from './featureManagementDetailLogic'
+
+function Metadata(): JSX.Element {
+    return (
+        <div className="flex flex-col gap-2">
+            <h2 className="font-semibold text-lg">Metadata</h2>
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+        </div>
+    )
+}
+
+function Rollout(): JSX.Element {
+    return (
+        <div className="flex flex-col gap-2">
+            <h2 className="font-semibold text-lg">Rollout</h2>
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+        </div>
+    )
+}
+
+function Usage(): JSX.Element {
+    return (
+        <div className="flex flex-col gap-2">
+            <h2 className="font-semibold text-lg">Usage</h2>
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+        </div>
+    )
+}
+
+function Activity(): JSX.Element {
+    return (
+        <div className="flex flex-col gap-2">
+            <h2 className="font-semibold text-lg">Activity</h2>
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+        </div>
+    )
+}
+
+function History(): JSX.Element {
+    return (
+        <div className="flex flex-col gap-2">
+            <h2 className="font-semibold text-lg">History</h2>
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+        </div>
+    )
+}
+
+function Permissions(): JSX.Element {
+    return (
+        <div className="flex flex-col gap-2">
+            <h2 className="font-semibold text-lg">Permissions</h2>
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+            <LemonSkeleton className="w-full h-4" active />
+        </div>
+    )
+}
+
+export function FeatureManagementDetail(): JSX.Element {
+    const { activeFeature } = useValues(featureManagementDetailLogic)
+
+    return (
+        <div className="flex flex-col gap-16">
+            <div className="text-xl font-bold">{activeFeature?.name}</div>
+            <Metadata />
+            <Rollout />
+            <Usage />
+            <Activity />
+            <History />
+            <Permissions />
+        </div>
+    )
+}
diff --git a/frontend/src/scenes/feature-flags/activityDescriptions.tsx b/frontend/src/scenes/feature-flags/activityDescriptions.tsx
index 93fec0692b0c3..a85f73cde21ad 100644
--- a/frontend/src/scenes/feature-flags/activityDescriptions.tsx
+++ b/frontend/src/scenes/feature-flags/activityDescriptions.tsx
@@ -252,6 +252,7 @@ const featureFlagActionsMapping: Record<
     analytics_dashboards: () => null,
     has_enriched_analytics: () => null,
     surveys: () => null,
+    user_access_level: () => null,
 }
 
 export function flagActivityDescriber(logItem: ActivityLogItem, asNotification?: boolean): HumanizedChange {
diff --git a/frontend/src/scenes/feature-flags/featureFlagLogic.ts b/frontend/src/scenes/feature-flags/featureFlagLogic.ts
index 48889df0f3d63..978348e795149 100644
--- a/frontend/src/scenes/feature-flags/featureFlagLogic.ts
+++ b/frontend/src/scenes/feature-flags/featureFlagLogic.ts
@@ -33,6 +33,7 @@ import {
     EarlyAccessFeatureType,
     FeatureFlagGroupType,
     FeatureFlagRollbackConditions,
+    FeatureFlagStatusResponse,
     FeatureFlagType,
     FilterLogicalOperator,
     FilterType,
@@ -43,6 +44,7 @@ import {
     MultivariateFlagVariant,
     NewEarlyAccessFeatureType,
     OrganizationFeatureFlag,
+    ProductKey,
     PropertyFilterType,
     PropertyOperator,
     QueryBasedInsightModel,
@@ -96,6 +98,7 @@ const NEW_FLAG: FeatureFlagType = {
     surveys: null,
     performed_rollback: false,
     can_edit: true,
+    user_access_level: 'editor',
     tags: [],
 }
 const NEW_VARIANT = {
@@ -268,6 +271,8 @@ export const featureFlagLogic = kea<featureFlagLogicType>([
             ['updateFlag', 'deleteFlag'],
             sidePanelStateLogic,
             ['closeSidePanel'],
+            teamLogic,
+            ['addProductIntent'],
         ],
     })),
     actions({
@@ -561,6 +566,7 @@ export const featureFlagLogic = kea<featureFlagLogicType>([
                         if (values.roleBasedAccessEnabled && savedFlag.id) {
                             featureFlagPermissionsLogic({ flagId: null })?.actions.addAssociatedRoles(savedFlag.id)
                         }
+                        actions.addProductIntent({ product_type: ProductKey.FEATURE_FLAGS })
                     } else {
                         savedFlag = await api.update(
                             `api/projects/${values.currentProjectId}/feature_flags/${updatedFlag.id}`,
@@ -750,6 +756,18 @@ export const featureFlagLogic = kea<featureFlagLogicType>([
                 }
             },
         },
+        flagStatus: [
+            null as FeatureFlagStatusResponse | null,
+            {
+                loadFeatureFlagStatus: () => {
+                    const { currentTeamId } = values
+                    if (currentTeamId && props.id && props.id !== 'new' && props.id !== 'link') {
+                        return api.featureFlags.getStatus(currentTeamId, props.id)
+                    }
+                    return null
+                },
+            },
+        ],
     })),
     listeners(({ actions, values, props }) => ({
         submitNewDashboardSuccessWithResult: async ({ result }) => {
@@ -1035,8 +1053,10 @@ export const featureFlagLogic = kea<featureFlagLogicType>([
             actions.setFeatureFlag(formatPayloadsWithFlag)
             actions.loadRelatedInsights()
             actions.loadAllInsightsForFlag()
+            actions.loadFeatureFlagStatus()
         } else if (props.id !== 'new') {
             actions.loadFeatureFlag()
+            actions.loadFeatureFlagStatus()
         }
     }),
 ])
diff --git a/frontend/src/scenes/feature-flags/featureManagementDetailLogic.ts b/frontend/src/scenes/feature-flags/featureManagementDetailLogic.ts
new file mode 100644
index 0000000000000..7389893c32860
--- /dev/null
+++ b/frontend/src/scenes/feature-flags/featureManagementDetailLogic.ts
@@ -0,0 +1,13 @@
+import { connect, kea, path, props } from 'kea'
+import { teamLogic } from 'scenes/teamLogic'
+
+import type { featureManagementDetailLogicType } from './featureManagementDetailLogicType'
+import { featureManagementLogic } from './featureManagementLogic'
+
+export const featureManagementDetailLogic = kea<featureManagementDetailLogicType>([
+    props({}),
+    path(['scenes', 'features', 'featureManagementDetailLogic']),
+    connect({
+        values: [teamLogic, ['currentTeamId'], featureManagementLogic, ['activeFeatureId', 'activeFeature']],
+    }),
+])
diff --git a/frontend/src/scenes/feature-flags/featureManagementLogic.ts b/frontend/src/scenes/feature-flags/featureManagementLogic.ts
new file mode 100644
index 0000000000000..b6de6f8b79bcf
--- /dev/null
+++ b/frontend/src/scenes/feature-flags/featureManagementLogic.ts
@@ -0,0 +1,101 @@
+import { actions, afterMount, connect, kea, listeners, path, props, reducers, selectors } from 'kea'
+import { loaders } from 'kea-loaders'
+import { actionToUrl, urlToAction } from 'kea-router'
+import api from 'lib/api'
+import { Scene } from 'scenes/sceneTypes'
+import { teamLogic } from 'scenes/teamLogic'
+import { urls } from 'scenes/urls'
+
+import { Breadcrumb, Feature } from '~/types'
+
+import type { featureManagementLogicType } from './featureManagementLogicType'
+
+export interface FeatureManagementLogicProps {
+    id?: Feature['id']
+}
+export interface FeaturesResult {
+    results: Feature[]
+    count: number
+    next?: string | null
+    previous?: string | null
+}
+
+export const featureManagementLogic = kea<featureManagementLogicType>([
+    props({} as FeatureManagementLogicProps),
+    path(['scenes', 'features', 'featureManagementLogic']),
+    connect({
+        values: [teamLogic, ['currentTeamId']],
+    }),
+    actions({
+        setActiveFeatureId: (activeFeatureId: Feature['id']) => ({ activeFeatureId }),
+    }),
+    reducers({
+        activeFeatureId: [
+            null as Feature['id'] | null,
+            {
+                setActiveFeatureId: (_, { activeFeatureId }) => activeFeatureId,
+            },
+        ],
+    }),
+    loaders(({ values }) => ({
+        features: [
+            { results: [], count: 0, offset: 0 } as FeaturesResult,
+            {
+                loadFeatures: async () => {
+                    const response = await api.get(`api/projects/${values.currentTeamId}/features`)
+                    return response.data as FeaturesResult
+                },
+            },
+        ],
+    })),
+    selectors({
+        activeFeature: [
+            (s) => [s.activeFeatureId, s.features],
+            (activeFeatureId, features) => features.results.find((feature) => feature.id === activeFeatureId) || null,
+        ],
+        breadcrumbs: [
+            (s) => [s.activeFeatureId, s.activeFeature],
+            (activeFeatureId, activeFeature): Breadcrumb[] => {
+                const breadcrumbs: Breadcrumb[] = [
+                    {
+                        key: Scene.FeatureManagement,
+                        name: 'Features',
+                        path: urls.featureManagement(),
+                    },
+                ]
+
+                if (activeFeatureId) {
+                    breadcrumbs.push({
+                        key: [Scene.FeatureManagement, activeFeatureId],
+                        name: activeFeature?.name ?? 'Feature',
+                        path: urls.featureManagement(String(activeFeatureId)),
+                    })
+                }
+
+                return breadcrumbs
+            },
+        ],
+    }),
+    listeners(({ actions, values }) => ({
+        loadFeaturesSuccess: ({ features }) => {
+            if (values.activeFeatureId === null && features.results.length > 0) {
+                actions.setActiveFeatureId(features.results[0].id)
+            }
+        },
+    })),
+    actionToUrl({
+        setActiveFeatureId: ({ activeFeatureId }) => {
+            return urls.featureManagement(activeFeatureId)
+        },
+    }),
+    urlToAction(({ actions, values }) => ({
+        '/features/:id': ({ id }) => {
+            if (id && String(values.activeFeatureId) !== id) {
+                actions.setActiveFeatureId(Number(id))
+            }
+        },
+    })),
+    afterMount(({ actions }) => {
+        actions.loadFeatures()
+    }),
+])
diff --git a/frontend/src/scenes/funnels/FunnelHistogram.tsx b/frontend/src/scenes/funnels/FunnelHistogram.tsx
index 1709b0eb514b4..39a157b7b878e 100644
--- a/frontend/src/scenes/funnels/FunnelHistogram.tsx
+++ b/frontend/src/scenes/funnels/FunnelHistogram.tsx
@@ -29,6 +29,7 @@ export function FunnelHistogram(): JSX.Element | null {
         <div
             className={clsx('FunnelHistogram', {
                 scrollable: !isInDashboardContext,
+                'overflow-hidden': isInDashboardContext,
                 'dashboard-wrapper': isInDashboardContext,
             })}
             ref={ref}
diff --git a/frontend/src/scenes/funnels/funnelDataLogic.ts b/frontend/src/scenes/funnels/funnelDataLogic.ts
index 0a48c272e929b..54ed637e4d2bd 100644
--- a/frontend/src/scenes/funnels/funnelDataLogic.ts
+++ b/frontend/src/scenes/funnels/funnelDataLogic.ts
@@ -169,6 +169,7 @@ export const funnelDataLogic = kea<funnelDataLogicType>([
                 if (
                     // TODO: Ideally we don't check filters anymore, but tests are still using this
                     insightData?.filters?.insight !== InsightType.FUNNELS &&
+                    querySource &&
                     querySource?.kind !== NodeKind.FunnelsQuery
                 ) {
                     return []
@@ -275,6 +276,7 @@ export const funnelDataLogic = kea<funnelDataLogicType>([
                 if (
                     // TODO: Ideally we don't check filters anymore, but tests are still using this
                     insightData?.filters?.insight !== InsightType.FUNNELS &&
+                    querySource &&
                     querySource?.kind !== NodeKind.FunnelsQuery
                 ) {
                     return false
diff --git a/frontend/src/scenes/groups/Group.tsx b/frontend/src/scenes/groups/Group.tsx
index ccd14aec76ce2..0aaf07f9a9cde 100644
--- a/frontend/src/scenes/groups/Group.tsx
+++ b/frontend/src/scenes/groups/Group.tsx
@@ -6,11 +6,13 @@ import { PageHeader } from 'lib/components/PageHeader'
 import { PropertiesTable } from 'lib/components/PropertiesTable'
 import { TZLabel } from 'lib/components/TZLabel'
 import { isEventFilter } from 'lib/components/UniversalFilters/utils'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
 import { LemonTabs } from 'lib/lemon-ui/LemonTabs'
 import { lemonToast } from 'lib/lemon-ui/LemonToast'
 import { Link } from 'lib/lemon-ui/Link'
 import { Spinner, SpinnerOverlay } from 'lib/lemon-ui/Spinner/Spinner'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { GroupDashboard } from 'scenes/groups/GroupDashboard'
 import { groupLogic, GroupLogicProps } from 'scenes/groups/groupLogic'
 import { RelatedGroups } from 'scenes/groups/RelatedGroups'
@@ -86,11 +88,14 @@ export function Group(): JSX.Element {
     const { groupKey, groupTypeIndex } = logicProps
     const { setGroupEventsQuery } = useActions(groupLogic)
     const { currentTeam } = useValues(teamLogic)
+    const { featureFlags } = useValues(featureFlagLogic)
 
     if (!groupData || !groupType) {
         return groupDataLoading ? <SpinnerOverlay sceneLevel /> : <NotFound object="group" />
     }
 
+    const settingLevel = featureFlags[FEATURE_FLAGS.ENVIRONMENTS] ? 'environment' : 'project'
+
     return (
         <>
             <PageHeader
@@ -145,8 +150,8 @@ export function Group(): JSX.Element {
                                 {!currentTeam?.session_recording_opt_in ? (
                                     <div className="mb-4">
                                         <LemonBanner type="info">
-                                            Session recordings are currently disabled for this project. To use this
-                                            feature, please go to your{' '}
+                                            Session recordings are currently disabled for this {settingLevel}. To use
+                                            this feature, please go to your{' '}
                                             <Link to={`${urls.settings('project')}#recordings`}>project settings</Link>{' '}
                                             and enable it.
                                         </LemonBanner>
diff --git a/frontend/src/scenes/insights/EmptyStates/EmptyStates.scss b/frontend/src/scenes/insights/EmptyStates/EmptyStates.scss
index ddae1edbb3113..de2ede18a2fb8 100644
--- a/frontend/src/scenes/insights/EmptyStates/EmptyStates.scss
+++ b/frontend/src/scenes/insights/EmptyStates/EmptyStates.scss
@@ -38,7 +38,9 @@
         }
 
         h2 {
+            width: 100%;
             text-align: center;
+            word-wrap: break-word;
         }
 
         ol {
diff --git a/frontend/src/scenes/insights/EmptyStates/EmptyStates.tsx b/frontend/src/scenes/insights/EmptyStates/EmptyStates.tsx
index 06f0928dc54f3..da29f417bf1f3 100644
--- a/frontend/src/scenes/insights/EmptyStates/EmptyStates.tsx
+++ b/frontend/src/scenes/insights/EmptyStates/EmptyStates.tsx
@@ -31,7 +31,7 @@ import { urls } from 'scenes/urls'
 
 import { actionsAndEventsToSeries } from '~/queries/nodes/InsightQuery/utils/filtersToQueryNode'
 import { seriesToActionsAndEvents } from '~/queries/nodes/InsightQuery/utils/queryNodeToFilter'
-import { FunnelsQuery, Node } from '~/queries/schema'
+import { FunnelsQuery, Node, QueryStatus } from '~/queries/schema'
 import { FilterType, InsightLogicProps, SavedInsightsTabs } from '~/types'
 
 import { samplingFilterLogic } from '../EditorFilters/samplingFilterLogic'
@@ -82,25 +82,22 @@ function humanFileSize(size: number): string {
     return (+(size / Math.pow(1024, i))).toFixed(2) + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i]
 }
 
-export function InsightLoadingState({
+export function StatelessInsightLoadingState({
     queryId,
-    insightProps,
+    pollResponse,
+    suggestion,
 }: {
     queryId?: string | null
-    insightProps: InsightLogicProps
+    pollResponse?: Record<string, QueryStatus | null> | null
+    suggestion?: JSX.Element
 }): JSX.Element {
-    const { suggestedSamplingPercentage, samplingPercentage } = useValues(samplingFilterLogic(insightProps))
-    const { insightPollResponse } = useValues(insightDataLogic(insightProps))
-
-    const { currentTeam } = useValues(teamLogic)
-
     const [rowsRead, setRowsRead] = useState(0)
     const [bytesRead, setBytesRead] = useState(0)
     const [secondsElapsed, setSecondsElapsed] = useState(0)
 
     useEffect(() => {
-        const status = insightPollResponse?.status?.query_progress
-        const previousStatus = insightPollResponse?.previousStatus?.query_progress
+        const status = pollResponse?.status?.query_progress
+        const previousStatus = pollResponse?.previousStatus?.query_progress
         setRowsRead(previousStatus?.rows_read || 0)
         setBytesRead(previousStatus?.bytes_read || 0)
         const interval = setInterval(() => {
@@ -113,21 +110,21 @@ export function InsightLoadingState({
                 return Math.min(bytesRead + diff / 30, status?.bytes_read || 0)
             })
             setSecondsElapsed(() => {
-                return dayjs().diff(dayjs(insightPollResponse?.status?.start_time), 'milliseconds')
+                return dayjs().diff(dayjs(pollResponse?.status?.start_time), 'milliseconds')
             })
         }, 100)
 
         return () => clearInterval(interval)
-    }, [insightPollResponse])
+    }, [pollResponse])
+
     const bytesPerSecond = (bytesRead / (secondsElapsed || 1)) * 1000
-    const estimatedRows = insightPollResponse?.status?.query_progress?.estimated_rows_total
+    const estimatedRows = pollResponse?.status?.query_progress?.estimated_rows_total
 
     const cpuUtilization =
-        (insightPollResponse?.status?.query_progress?.active_cpu_time || 0) /
-        (insightPollResponse?.status?.query_progress?.time_elapsed || 1) /
+        (pollResponse?.status?.query_progress?.active_cpu_time || 0) /
+        (pollResponse?.status?.query_progress?.time_elapsed || 1) /
         10000
 
-    currentTeam?.modifiers?.personsOnEventsMode ?? currentTeam?.default_modifiers?.personsOnEventsMode ?? 'disabled'
     return (
         <div className="insight-empty-state warning">
             <div className="empty-state-inner">
@@ -148,37 +145,14 @@ export function InsightLoadingState({
                         </>
                     )}
                 </p>
-                <div className="flex items-center p-4 rounded bg-bg-3000 gap-x-3 max-w-120">
-                    {currentTeam?.modifiers?.personsOnEventsMode === 'person_id_override_properties_joined' ? (
-                        <>
-                            <IconWarning className="text-xl shrink-0 text-warning" />
-                            <p className="text-xs m-0">
-                                You can speed this query up by changing the{' '}
-                                <Link to="/settings/project#persons-on-events">person properties mode</Link> setting.
-                            </p>
-                        </>
-                    ) : (
-                        <>
-                            <IconInfo className="text-xl shrink-0" />
-                            <p className="text-xs m-0">
-                                {suggestedSamplingPercentage && !samplingPercentage ? (
-                                    <span data-attr="insight-loading-waiting-message">
-                                        Need to speed things up? Try reducing the date range, removing breakdowns, or
-                                        turning on <SamplingLink insightProps={insightProps} />.
-                                    </span>
-                                ) : suggestedSamplingPercentage && samplingPercentage ? (
-                                    <>
-                                        Still waiting around? You must have lots of data! Kick it up a notch with{' '}
-                                        <SamplingLink insightProps={insightProps} />. Or try reducing the date range and
-                                        removing breakdowns.
-                                    </>
-                                ) : (
-                                    <>Need to speed things up? Try reducing the date range or removing breakdowns.</>
-                                )}
-                            </p>
-                        </>
-                    )}
-                </div>
+                {suggestion ? (
+                    suggestion
+                ) : (
+                    <div className="flex items-center p-4 rounded bg-bg-3000 gap-x-3 max-w-120">
+                        <IconInfo className="text-xl shrink-0" />
+                        <p className="text-xs m-0">Need to speed things up? Try reducing the date range.</p>
+                    </div>
+                )}
                 {queryId ? (
                     <div className="text-muted text-xs mx-auto text-center mt-5">
                         Query ID: <span className="font-mono">{queryId}</span>
@@ -189,6 +163,66 @@ export function InsightLoadingState({
     )
 }
 
+export function InsightLoadingState({
+    queryId,
+    insightProps,
+}: {
+    queryId?: string | null
+    insightProps: InsightLogicProps
+}): JSX.Element {
+    const { suggestedSamplingPercentage, samplingPercentage } = useValues(samplingFilterLogic(insightProps))
+    const { insightPollResponse } = useValues(insightDataLogic(insightProps))
+    const { currentTeam } = useValues(teamLogic)
+
+    const personsOnEventsMode =
+        currentTeam?.modifiers?.personsOnEventsMode ?? currentTeam?.default_modifiers?.personsOnEventsMode ?? 'disabled'
+
+    return (
+        <div>
+            <StatelessInsightLoadingState
+                queryId={queryId}
+                pollResponse={insightPollResponse}
+                suggestion={
+                    <div className="flex items-center p-4 rounded bg-bg-3000 gap-x-3 max-w-120">
+                        {personsOnEventsMode === 'person_id_override_properties_joined' ? (
+                            <>
+                                <IconWarning className="text-xl shrink-0 text-warning" />
+                                <p className="text-xs m-0">
+                                    You can speed this query up by changing the{' '}
+                                    <Link to="/settings/project#persons-on-events">person properties mode</Link>{' '}
+                                    setting.
+                                </p>
+                            </>
+                        ) : (
+                            <>
+                                <IconInfo className="text-xl shrink-0" />
+                                <p className="text-xs m-0">
+                                    {suggestedSamplingPercentage && !samplingPercentage ? (
+                                        <span data-attr="insight-loading-waiting-message">
+                                            Need to speed things up? Try reducing the date range, removing breakdowns,
+                                            or turning on <SamplingLink insightProps={insightProps} />.
+                                        </span>
+                                    ) : suggestedSamplingPercentage && samplingPercentage ? (
+                                        <>
+                                            Still waiting around? You must have lots of data! Kick it up a notch with{' '}
+                                            <SamplingLink insightProps={insightProps} />. Or try reducing the date range
+                                            and removing breakdowns.
+                                        </>
+                                    ) : (
+                                        <>
+                                            Need to speed things up? Try reducing the date range or removing breakdowns.
+                                        </>
+                                    )}
+                                </p>
+                            </>
+                        )}
+                    </div>
+                }
+            />
+        </div>
+    )
+}
+
 export function InsightTimeoutState({ queryId }: { queryId?: string | null }): JSX.Element {
     const { openSupportForm } = useActions(supportLogic)
 
diff --git a/frontend/src/scenes/insights/insightVizDataLogic.ts b/frontend/src/scenes/insights/insightVizDataLogic.ts
index aec4a1eb32ed8..14b0b4cbd393d 100644
--- a/frontend/src/scenes/insights/insightVizDataLogic.ts
+++ b/frontend/src/scenes/insights/insightVizDataLogic.ts
@@ -100,6 +100,7 @@ export const insightVizDataLogic = kea<insightVizDataLogicType>([
         updateDisplay: (display: ChartDisplayType | undefined) => ({ display }),
         updateHiddenLegendIndexes: (hiddenLegendIndexes: number[] | undefined) => ({ hiddenLegendIndexes }),
         setTimedOutQueryId: (id: string | null) => ({ id }),
+        setIsIntervalManuallySet: (isIntervalManuallySet: boolean) => ({ isIntervalManuallySet }),
     }),
 
     reducers({
@@ -109,6 +110,18 @@ export const insightVizDataLogic = kea<insightVizDataLogicType>([
                 setTimedOutQueryId: (_, { id }) => id,
             },
         ],
+
+        // Whether the interval has been manually set by the user. If true, prevents auto-adjusting the interval when date range changes. Reference: https://github.com/PostHog/posthog/issues/22785
+        isIntervalManuallySet: [
+            false,
+            {
+                updateQuerySource: (state, { querySource }) => {
+                    // If interval is explicitly included in the update, mark it as manually set
+                    return 'interval' in querySource ? true : state
+                },
+                setIsIntervalManuallySet: (_, { isIntervalManuallySet }) => isIntervalManuallySet,
+            },
+        ],
     }),
 
     selectors({
@@ -332,7 +345,7 @@ export const insightVizDataLogic = kea<insightVizDataLogicType>([
                 // We use 512 for query timeouts
                 // Async queries put the error message on data.error_message, while synchronous ones use detail
                 return insightDataError?.status === 400 || insightDataError?.status === 512
-                    ? (insightDataError.detail || insightDataError.data?.error_message)?.replace('Try ', 'Try ') // Add unbreakable space for better line breaking
+                    ? (insightDataError.detail || insightDataError.data?.error_message)?.replace('Try ', 'Try ') // Add unbreakable space for better line breaking
                     : null
             },
         ],
@@ -401,7 +414,11 @@ export const insightVizDataLogic = kea<insightVizDataLogicType>([
                 ...values.query,
                 source: {
                     ...values.querySource,
-                    ...handleQuerySourceUpdateSideEffects(querySource, values.querySource as InsightQueryNode),
+                    ...handleQuerySourceUpdateSideEffects(
+                        querySource,
+                        values.querySource as InsightQueryNode,
+                        values.isIntervalManuallySet
+                    ),
                 },
             } as Node)
         },
@@ -487,7 +504,8 @@ const getActiveUsersMath = (
 
 const handleQuerySourceUpdateSideEffects = (
     update: QuerySourceUpdate,
-    currentState: InsightQueryNode
+    currentState: InsightQueryNode,
+    isIntervalManuallySet: boolean
 ): QuerySourceUpdate => {
     const mergedUpdate = { ...update } as InsightQueryNode
 
@@ -536,7 +554,8 @@ const handleQuerySourceUpdateSideEffects = (
         update.dateRange &&
         update.dateRange.date_from &&
         (update.dateRange.date_from !== currentState.dateRange?.date_from ||
-            update.dateRange.date_to !== currentState.dateRange?.date_to)
+            update.dateRange.date_to !== currentState.dateRange?.date_to) &&
+        !isIntervalManuallySet // Only auto-adjust interval if not manually set
     ) {
         const { date_from, date_to } = { ...currentState.dateRange, ...update.dateRange }
 
diff --git a/frontend/src/scenes/instance/SystemStatus/staffUsersLogic.ts b/frontend/src/scenes/instance/SystemStatus/staffUsersLogic.ts
index 51054ab2fa8ac..3ac34a80e733b 100644
--- a/frontend/src/scenes/instance/SystemStatus/staffUsersLogic.ts
+++ b/frontend/src/scenes/instance/SystemStatus/staffUsersLogic.ts
@@ -33,8 +33,7 @@ export const staffUsersLogic = kea<staffUsersLogicType>([
                     actions.setStaffUsersToBeAdded([])
                     const newStaffUsers = await Promise.all(
                         staffUsersToBeAdded.map(
-                            async (userUuid) =>
-                                (await api.update(`api/users/${userUuid}`, { is_staff: true })) as UserType
+                            async (userUuid) => await api.update<UserType>(`api/users/${userUuid}`, { is_staff: true })
                         )
                     )
                     const updatedAllUsers: UserType[] = [
@@ -45,7 +44,7 @@ export const staffUsersLogic = kea<staffUsersLogicType>([
                     return updatedAllUsers
                 },
                 deleteStaffUser: async ({ userUuid }) => {
-                    await api.update(`api/users/${userUuid}`, { is_staff: false })
+                    await api.update<UserType>(`api/users/${userUuid}`, { is_staff: false })
                     if (values.user?.uuid === userUuid) {
                         actions.loadUser() // Loads the main user object to properly reflect staff user changes
                         router.actions.push(urls.projectHomepage())
diff --git a/frontend/src/scenes/max/Intro.tsx b/frontend/src/scenes/max/Intro.tsx
index c43cd86b53d2a..97f4f9fbfdc56 100644
--- a/frontend/src/scenes/max/Intro.tsx
+++ b/frontend/src/scenes/max/Intro.tsx
@@ -3,6 +3,7 @@ import { LemonButton, Popover } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { HedgehogBuddy } from 'lib/components/HedgehogBuddy/HedgehogBuddy'
 import { hedgehogBuddyLogic } from 'lib/components/HedgehogBuddy/hedgehogBuddyLogic'
+import { uuid } from 'lib/utils'
 import { useMemo, useState } from 'react'
 
 import { maxGlobalLogic } from './maxGlobalLogic'
@@ -19,13 +20,13 @@ export function Intro(): JSX.Element {
     const { hedgehogConfig } = useValues(hedgehogBuddyLogic)
     const { acceptDataProcessing } = useActions(maxGlobalLogic)
     const { dataProcessingAccepted } = useValues(maxGlobalLogic)
-    const { sessionId } = useValues(maxLogic)
+    const { conversation } = useValues(maxLogic)
 
     const [hedgehogDirection, setHedgehogDirection] = useState<'left' | 'right'>('right')
 
     const headline = useMemo(() => {
-        return HEADLINES[parseInt(sessionId.split('-').at(-1) as string, 16) % HEADLINES.length]
-    }, [])
+        return HEADLINES[parseInt((conversation?.id || uuid()).split('-').at(-1) as string, 16) % HEADLINES.length]
+    }, [conversation?.id])
 
     return (
         <>
diff --git a/frontend/src/scenes/max/Max.stories.tsx b/frontend/src/scenes/max/Max.stories.tsx
index bec5a519de8e0..51dc03ab0cb5c 100644
--- a/frontend/src/scenes/max/Max.stories.tsx
+++ b/frontend/src/scenes/max/Max.stories.tsx
@@ -6,7 +6,13 @@ import { projectLogic } from 'scenes/projectLogic'
 
 import { mswDecorator, useStorybookMocks } from '~/mocks/browser'
 
-import { chatResponseChunk, failureChunk, generationFailureChunk } from './__mocks__/chatResponse.mocks'
+import {
+    chatResponseChunk,
+    CONVERSATION_ID,
+    failureChunk,
+    generationFailureChunk,
+    humanMessage,
+} from './__mocks__/chatResponse.mocks'
 import { MaxInstance } from './Max'
 import { maxGlobalLogic } from './maxGlobalLogic'
 import { maxLogic } from './maxLogic'
@@ -16,7 +22,7 @@ const meta: Meta = {
     decorators: [
         mswDecorator({
             post: {
-                '/api/environments/:team_id/query/chat/': (_, res, ctx) => res(ctx.text(chatResponseChunk)),
+                '/api/environments/:team_id/conversations/': (_, res, ctx) => res(ctx.text(chatResponseChunk)),
             },
         }),
     ],
@@ -28,10 +34,7 @@ const meta: Meta = {
 }
 export default meta
 
-// The session ID is hard-coded here, as it's used for randomizing the welcome headline
-const SESSION_ID = 'b1b4b3b4-1b3b-4b3b-1b3b4b3b4b3b'
-
-const Template = ({ sessionId: SESSION_ID }: { sessionId: string }): JSX.Element => {
+const Template = ({ conversationId: CONVERSATION_ID }: { conversationId: string }): JSX.Element => {
     const { acceptDataProcessing } = useActions(maxGlobalLogic)
 
     useEffect(() => {
@@ -40,7 +43,7 @@ const Template = ({ sessionId: SESSION_ID }: { sessionId: string }): JSX.Element
 
     return (
         <div className="relative flex flex-col h-fit">
-            <BindLogic logic={maxLogic} props={{ sessionId: SESSION_ID }}>
+            <BindLogic logic={maxLogic} props={{ conversationId: CONVERSATION_ID }}>
                 <MaxInstance />
             </BindLogic>
         </div>
@@ -69,7 +72,7 @@ export const Welcome: StoryFn = () => {
         acceptDataProcessing(false)
     }, [])
 
-    return <Template sessionId={SESSION_ID} />
+    return <Template conversationId={CONVERSATION_ID} />
 }
 
 export const WelcomeSuggestionsAvailable: StoryFn = () => {
@@ -95,7 +98,7 @@ export const WelcomeLoadingSuggestions: StoryFn = () => {
         loadCurrentProjectSuccess({ ...MOCK_DEFAULT_PROJECT, product_description: 'A Storybook test.' })
     }, [])
 
-    return <Template sessionId={SESSION_ID} />
+    return <Template conversationId={CONVERSATION_ID} />
 }
 WelcomeLoadingSuggestions.parameters = {
     testOptions: {
@@ -104,29 +107,29 @@ WelcomeLoadingSuggestions.parameters = {
 }
 
 export const Thread: StoryFn = () => {
-    const { askMax } = useActions(maxLogic({ sessionId: SESSION_ID }))
+    const { askMax } = useActions(maxLogic({ conversationId: CONVERSATION_ID }))
 
     useEffect(() => {
-        askMax('What are my most popular pages?')
+        askMax(humanMessage.content)
     }, [])
 
-    return <Template sessionId={SESSION_ID} />
+    return <Template conversationId={CONVERSATION_ID} />
 }
 
 export const EmptyThreadLoading: StoryFn = () => {
     useStorybookMocks({
         post: {
-            '/api/environments/:team_id/query/chat/': (_req, _res, ctx) => [ctx.delay('infinite')],
+            '/api/environments/:team_id/conversations/': (_req, _res, ctx) => [ctx.delay('infinite')],
         },
     })
 
-    const { askMax } = useActions(maxLogic({ sessionId: SESSION_ID }))
+    const { askMax } = useActions(maxLogic({ conversationId: CONVERSATION_ID }))
 
     useEffect(() => {
-        askMax('What are my most popular pages?')
+        askMax(humanMessage.content)
     }, [])
 
-    return <Template sessionId={SESSION_ID} />
+    return <Template conversationId={CONVERSATION_ID} />
 }
 EmptyThreadLoading.parameters = {
     testOptions: {
@@ -137,15 +140,15 @@ EmptyThreadLoading.parameters = {
 export const GenerationFailureThread: StoryFn = () => {
     useStorybookMocks({
         post: {
-            '/api/environments/:team_id/query/chat/': (_, res, ctx) => res(ctx.text(generationFailureChunk)),
+            '/api/environments/:team_id/conversations/': (_, res, ctx) => res(ctx.text(generationFailureChunk)),
         },
     })
 
-    const { askMax, setMessageStatus } = useActions(maxLogic({ sessionId: SESSION_ID }))
-    const { threadRaw, threadLoading } = useValues(maxLogic({ sessionId: SESSION_ID }))
+    const { askMax, setMessageStatus } = useActions(maxLogic({ conversationId: CONVERSATION_ID }))
+    const { threadRaw, threadLoading } = useValues(maxLogic({ conversationId: CONVERSATION_ID }))
 
     useEffect(() => {
-        askMax('What are my most popular pages?')
+        askMax(humanMessage.content)
     }, [])
 
     useEffect(() => {
@@ -154,38 +157,38 @@ export const GenerationFailureThread: StoryFn = () => {
         }
     }, [threadRaw.length, threadLoading])
 
-    return <Template sessionId={SESSION_ID} />
+    return <Template conversationId={CONVERSATION_ID} />
 }
 
 export const ThreadWithFailedGeneration: StoryFn = () => {
     useStorybookMocks({
         post: {
-            '/api/environments/:team_id/query/chat/': (_, res, ctx) => res(ctx.text(failureChunk)),
+            '/api/environments/:team_id/conversations/': (_, res, ctx) => res(ctx.text(failureChunk)),
         },
     })
 
-    const { askMax } = useActions(maxLogic({ sessionId: SESSION_ID }))
+    const { askMax } = useActions(maxLogic({ conversationId: CONVERSATION_ID }))
 
     useEffect(() => {
-        askMax('What are my most popular pages?')
+        askMax(humanMessage.content)
     }, [])
 
-    return <Template sessionId={SESSION_ID} />
+    return <Template conversationId={CONVERSATION_ID} />
 }
 
 export const ThreadWithRateLimit: StoryFn = () => {
     useStorybookMocks({
         post: {
-            '/api/environments/:team_id/query/chat/': (_, res, ctx) =>
+            '/api/environments/:team_id/conversations/': (_, res, ctx) =>
                 res(ctx.text(chatResponseChunk), ctx.status(429)),
         },
     })
 
-    const { askMax } = useActions(maxLogic({ sessionId: SESSION_ID }))
+    const { askMax } = useActions(maxLogic({ conversationId: CONVERSATION_ID }))
 
     useEffect(() => {
         askMax('Is Bielefeld real?')
     }, [])
 
-    return <Template sessionId={SESSION_ID} />
+    return <Template conversationId={CONVERSATION_ID} />
 }
diff --git a/frontend/src/scenes/max/Max.tsx b/frontend/src/scenes/max/Max.tsx
index d7025cb06eafd..cf5892f497f35 100644
--- a/frontend/src/scenes/max/Max.tsx
+++ b/frontend/src/scenes/max/Max.tsx
@@ -2,8 +2,6 @@ import { BindLogic, useValues } from 'kea'
 import { NotFound } from 'lib/components/NotFound'
 import { FEATURE_FLAGS } from 'lib/constants'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
-import { uuid } from 'lib/utils'
-import { useMemo } from 'react'
 import { SceneExport } from 'scenes/sceneTypes'
 
 import { Intro } from './Intro'
@@ -19,14 +17,12 @@ export const scene: SceneExport = {
 export function Max(): JSX.Element {
     const { featureFlags } = useValues(featureFlagLogic)
 
-    const sessionId = useMemo(() => uuid(), [])
-
     if (!featureFlags[FEATURE_FLAGS.ARTIFICIAL_HOG]) {
         return <NotFound object="page" caption="You don't have access to AI features yet." />
     }
 
     return (
-        <BindLogic logic={maxLogic} props={{ sessionId }}>
+        <BindLogic logic={maxLogic} props={{ conversationId: null }}>
             <MaxInstance />
         </BindLogic>
     )
diff --git a/frontend/src/scenes/max/Thread.tsx b/frontend/src/scenes/max/Thread.tsx
index 5014d8a752509..f8a5d56d0650b 100644
--- a/frontend/src/scenes/max/Thread.tsx
+++ b/frontend/src/scenes/max/Thread.tsx
@@ -83,10 +83,12 @@ function MessageGroup({ messages, isFinal: isGroupFinal, index: messageGroupInde
                 )}
             >
                 {messages.map((message, messageIndex) => {
+                    const key = message.id || messageIndex
+
                     if (isHumanMessage(message)) {
                         return (
                             <MessageTemplate
-                                key={messageIndex}
+                                key={key}
                                 type="human"
                                 boxClassName={message.status === 'error' ? 'border-danger' : undefined}
                             >
@@ -96,7 +98,7 @@ function MessageGroup({ messages, isFinal: isGroupFinal, index: messageGroupInde
                     } else if (isAssistantMessage(message) || isFailureMessage(message)) {
                         return (
                             <TextAnswer
-                                key={messageIndex}
+                                key={key}
                                 message={message}
                                 rateable={messageIndex === messages.length - 1}
                                 retriable={messageIndex === messages.length - 1 && isGroupFinal}
@@ -107,7 +109,7 @@ function MessageGroup({ messages, isFinal: isGroupFinal, index: messageGroupInde
                         return <VisualizationAnswer key={messageIndex} message={message} status={message.status} />
                     } else if (isReasoningMessage(message)) {
                         return (
-                            <MessageTemplate key={messageIndex} type="ai">
+                            <MessageTemplate key={key} type="ai">
                                 <div className="flex items-center gap-2">
                                     <span>{message.content}…</span>
                                     <Spinner className="text-xl" />
diff --git a/frontend/src/scenes/max/__mocks__/chatResponse.mocks.ts b/frontend/src/scenes/max/__mocks__/chatResponse.mocks.ts
index ce9930b986211..6acfc72bd5914 100644
--- a/frontend/src/scenes/max/__mocks__/chatResponse.mocks.ts
+++ b/frontend/src/scenes/max/__mocks__/chatResponse.mocks.ts
@@ -2,6 +2,7 @@ import {
     AssistantGenerationStatusEvent,
     AssistantGenerationStatusType,
     AssistantMessageType,
+    HumanMessage,
     ReasoningMessage,
 } from '~/queries/schema'
 
@@ -9,16 +10,25 @@ import failureMessage from './failureMessage.json'
 import summaryMessage from './summaryMessage.json'
 import visualizationMessage from './visualizationMessage.json'
 
+// The session ID is hard-coded here, as it's used for randomizing the welcome headline
+export const CONVERSATION_ID = 'b1b4b3b4-1b3b-4b3b-1b3b4b3b4b3b'
+
+export const humanMessage: HumanMessage = {
+    type: AssistantMessageType.Human,
+    content: 'What are my most popular pages?',
+    id: 'human-1',
+}
+
 const reasoningMessage1: ReasoningMessage = {
     type: AssistantMessageType.Reasoning,
     content: 'Picking relevant events and properties',
-    done: true,
+    id: 'reasoning-1',
 }
 
 const reasoningMessage2: ReasoningMessage = {
     type: AssistantMessageType.Reasoning,
     content: 'Generating trends',
-    done: true,
+    id: 'reasoning-2',
 }
 
 function generateChunk(events: string[]): string {
@@ -26,6 +36,10 @@ function generateChunk(events: string[]): string {
 }
 
 export const chatResponseChunk = generateChunk([
+    'event: conversation',
+    `data: ${JSON.stringify({ id: CONVERSATION_ID })}`,
+    'event: message',
+    `data: ${JSON.stringify(humanMessage)}`,
     'event: message',
     `data: ${JSON.stringify(reasoningMessage1)}`,
     'event: message',
diff --git a/frontend/src/scenes/max/__mocks__/failureMessage.json b/frontend/src/scenes/max/__mocks__/failureMessage.json
index 66ab38b6c49ca..5667c02bd65a4 100644
--- a/frontend/src/scenes/max/__mocks__/failureMessage.json
+++ b/frontend/src/scenes/max/__mocks__/failureMessage.json
@@ -1,5 +1,5 @@
 {
     "type": "ai/failure",
     "content": "Oops! It looks like I’m having trouble generating this trends insight. Could you please try again?",
-    "done": true
+    "id": "test-failure-message"
 }
diff --git a/frontend/src/scenes/max/__mocks__/summaryMessage.json b/frontend/src/scenes/max/__mocks__/summaryMessage.json
index 011565dc126e2..c7ff5d635f0ec 100644
--- a/frontend/src/scenes/max/__mocks__/summaryMessage.json
+++ b/frontend/src/scenes/max/__mocks__/summaryMessage.json
@@ -1,5 +1,5 @@
 {
     "type": "ai",
     "content": "Looks like no pageviews have occured. Get some damn users.",
-    "done": true
+    "id": "test-summary-message"
 }
diff --git a/frontend/src/scenes/max/__mocks__/visualizationMessage.json b/frontend/src/scenes/max/__mocks__/visualizationMessage.json
index 63f21b458ef48..a9a0e1c44d6c9 100644
--- a/frontend/src/scenes/max/__mocks__/visualizationMessage.json
+++ b/frontend/src/scenes/max/__mocks__/visualizationMessage.json
@@ -56,5 +56,5 @@
             "yAxisScaleType": null
         }
     },
-    "done": true
+    "id": "test-visualization-message"
 }
diff --git a/frontend/src/scenes/max/maxLogic.ts b/frontend/src/scenes/max/maxLogic.ts
index aa8c66e7f9e40..74316cc3ed439 100644
--- a/frontend/src/scenes/max/maxLogic.ts
+++ b/frontend/src/scenes/max/maxLogic.ts
@@ -4,7 +4,8 @@ import { createParser } from 'eventsource-parser'
 import { actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
 import { loaders } from 'kea-loaders'
 import api, { ApiError } from 'lib/api'
-import { isHumanMessage, isVisualizationMessage } from 'scenes/max/utils'
+import { uuid } from 'lib/utils'
+import { isHumanMessage, isReasoningMessage, isVisualizationMessage } from 'scenes/max/utils'
 import { projectLogic } from 'scenes/projectLogic'
 
 import {
@@ -20,11 +21,12 @@ import {
     RootAssistantMessage,
     SuggestedQuestionsQuery,
 } from '~/queries/schema'
+import { Conversation } from '~/types'
 
 import type { maxLogicType } from './maxLogicType'
 
 export interface MaxLogicProps {
-    sessionId: string
+    conversationId?: string
 }
 
 export type MessageStatus = 'loading' | 'completed' | 'error'
@@ -37,13 +39,12 @@ const FAILURE_MESSAGE: FailureMessage & ThreadMessage = {
     type: AssistantMessageType.Failure,
     content: 'Oops! It looks like I’m having trouble generating this trends insight. Could you please try again?',
     status: 'completed',
-    done: true,
 }
 
 export const maxLogic = kea<maxLogicType>([
     path(['scenes', 'max', 'maxLogic']),
     props({} as MaxLogicProps),
-    key(({ sessionId }) => sessionId),
+    key(({ conversationId }) => conversationId || 'new-conversation'),
     connect({
         values: [projectLogic, ['currentProject']],
     }),
@@ -58,6 +59,7 @@ export const maxLogic = kea<maxLogicType>([
         shuffleVisibleSuggestions: true,
         retryLastMessage: true,
         scrollThreadToBottom: true,
+        setConversation: (conversation: Conversation) => ({ conversation }),
     }),
     reducers({
         question: [
@@ -67,6 +69,12 @@ export const maxLogic = kea<maxLogicType>([
                 askMax: () => '',
             },
         ],
+        conversation: [
+            (_, props) => (props.conversationId ? ({ id: props.conversationId } as Conversation) : null),
+            {
+                setConversation: (_, { conversation }) => conversation,
+            },
+        ],
         threadRaw: [
             [] as ThreadMessage[],
             {
@@ -84,6 +92,7 @@ export const maxLogic = kea<maxLogicType>([
                     },
                     ...state.slice(index + 1),
                 ],
+                setThreadLoaded: (state) => state.filter((message) => !isReasoningMessage(message)),
             },
         ],
         threadLoading: [
@@ -117,7 +126,7 @@ export const maxLogic = kea<maxLogicType>([
             },
         ],
     }),
-    listeners(({ actions, values, props }) => ({
+    listeners(({ actions, values }) => ({
         [projectLogic.actionTypes.updateCurrentProjectSuccess]: ({ payload }) => {
             // Load suggestions anew after product description is changed on the project
             // Most important when description is set for the first time, but also when updated,
@@ -155,11 +164,11 @@ export const maxLogic = kea<maxLogicType>([
             )
         },
         askMax: async ({ prompt }) => {
-            actions.addMessage({ type: AssistantMessageType.Human, content: prompt, done: true, status: 'completed' })
+            actions.addMessage({ type: AssistantMessageType.Human, content: prompt, status: 'completed' })
             try {
-                const response = await api.chat({
-                    session_id: props.sessionId,
-                    messages: values.threadRaw.map(({ status, ...message }) => message),
+                const response = await api.conversations.create({
+                    content: prompt,
+                    conversation: values.conversation?.id,
                 })
                 const reader = response.body?.getReader()
 
@@ -177,15 +186,20 @@ export const maxLogic = kea<maxLogicType>([
                                 return
                             }
 
-                            if (values.threadRaw[values.threadRaw.length - 1].status === 'completed') {
+                            if (isHumanMessage(parsedResponse)) {
+                                actions.replaceMessage(values.threadRaw.length - 1, {
+                                    ...parsedResponse,
+                                    status: 'completed',
+                                })
+                            } else if (values.threadRaw[values.threadRaw.length - 1].status === 'completed') {
                                 actions.addMessage({
                                     ...parsedResponse,
-                                    status: !parsedResponse.done ? 'loading' : 'completed',
+                                    status: !parsedResponse.id ? 'loading' : 'completed',
                                 })
                             } else if (parsedResponse) {
                                 actions.replaceMessage(values.threadRaw.length - 1, {
                                     ...parsedResponse,
-                                    status: !parsedResponse.done ? 'loading' : 'completed',
+                                    status: !parsedResponse.id ? 'loading' : 'completed',
                                 })
                             }
                         } else if (event === AssistantEventType.Status) {
@@ -197,6 +211,12 @@ export const maxLogic = kea<maxLogicType>([
                             if (parsedResponse.type === AssistantGenerationStatusType.GenerationError) {
                                 actions.setMessageStatus(values.threadRaw.length - 1, 'error')
                             }
+                        } else if (event === AssistantEventType.Conversation) {
+                            const parsedResponse = parseResponse<Conversation>(data)
+                            if (!parsedResponse) {
+                                return
+                            }
+                            actions.setConversation(parsedResponse)
                         }
                     },
                 })
@@ -209,7 +229,7 @@ export const maxLogic = kea<maxLogicType>([
                     }
                 }
             } catch (e) {
-                const relevantErrorMessage = { ...FAILURE_MESSAGE } // Generic message by default
+                const relevantErrorMessage = { ...FAILURE_MESSAGE, id: uuid() } // Generic message by default
                 if (e instanceof ApiError && e.status === 429) {
                     relevantErrorMessage.content = "You've reached my usage limit for now. Please try again later."
                 } else {
@@ -253,7 +273,6 @@ export const maxLogic = kea<maxLogicType>([
         },
     })),
     selectors({
-        sessionId: [(_, p) => [p.sessionId], (sessionId) => sessionId],
         threadGrouped: [
             (s) => [s.threadRaw, s.threadLoading],
             (thread, threadLoading): ThreadMessage[][] => {
@@ -263,7 +282,7 @@ export const maxLogic = kea<maxLogicType>([
                     const previousMessage: ThreadMessage | undefined = thread[i - 1]
                     if (currentMessage.type.split('/')[0] === previousMessage?.type.split('/')[0]) {
                         const lastThreadSoFar = threadGrouped[threadGrouped.length - 1]
-                        if (currentMessage.done && previousMessage.type === AssistantMessageType.Reasoning) {
+                        if (currentMessage.id && previousMessage.type === AssistantMessageType.Reasoning) {
                             // Only preserve the latest reasoning message, and remove once reasoning is done
                             lastThreadSoFar[lastThreadSoFar.length - 1] = currentMessage
                         } else {
@@ -275,14 +294,17 @@ export const maxLogic = kea<maxLogicType>([
                 }
                 if (threadLoading) {
                     const finalMessageSoFar = threadGrouped.at(-1)?.at(-1)
-                    if (finalMessageSoFar?.done && finalMessageSoFar.type !== AssistantMessageType.Reasoning) {
+                    if (
+                        finalMessageSoFar?.type === AssistantMessageType.Human ||
+                        (finalMessageSoFar?.id && finalMessageSoFar.type !== AssistantMessageType.Reasoning)
+                    ) {
                         // If now waiting for the current node to start streaming, add "Thinking" message
                         // so that there's _some_ indication of processing
                         const thinkingMessage: ReasoningMessage & ThreadMessage = {
                             type: AssistantMessageType.Reasoning,
                             content: 'Thinking',
                             status: 'completed',
-                            done: true,
+                            id: 'loader',
                         }
                         if (finalMessageSoFar.type === AssistantMessageType.Human) {
                             // If the last message was human, we need to add a new "ephemeral" AI group
diff --git a/frontend/src/scenes/notebooks/Notebook/__mocks__/notebook-template-for-snapshot.ts b/frontend/src/scenes/notebooks/Notebook/__mocks__/notebook-template-for-snapshot.ts
index 175647c05a7a6..e1cdf46446ef8 100644
--- a/frontend/src/scenes/notebooks/Notebook/__mocks__/notebook-template-for-snapshot.ts
+++ b/frontend/src/scenes/notebooks/Notebook/__mocks__/notebook-template-for-snapshot.ts
@@ -14,6 +14,7 @@ export const notebookTestTemplate = (
     last_modified_at: '2023-06-02T00:00:00Z',
     created_by: MOCK_DEFAULT_BASIC_USER,
     last_modified_by: MOCK_DEFAULT_BASIC_USER,
+    user_access_level: 'editor' as const,
     version: 1,
     content: {
         type: 'doc',
diff --git a/frontend/src/scenes/notebooks/Notebook/migrations/migrate.test.ts b/frontend/src/scenes/notebooks/Notebook/migrations/migrate.test.ts
index d1409e1716f6d..2dd7b6aa1915d 100644
--- a/frontend/src/scenes/notebooks/Notebook/migrations/migrate.test.ts
+++ b/frontend/src/scenes/notebooks/Notebook/migrations/migrate.test.ts
@@ -933,10 +933,12 @@ describe('migrate()', () => {
     it.each(contentToExpected)('migrates %s', (_name, prevContent, nextContent) => {
         const prevNotebook: NotebookType = {
             ...mockNotebook,
+            user_access_level: 'editor' as const,
             content: { type: 'doc', content: prevContent },
         }
         const nextNotebook: NotebookType = {
             ...mockNotebook,
+            user_access_level: 'editor' as const,
             content: { type: 'doc', content: nextContent },
         }
 
diff --git a/frontend/src/scenes/notebooks/Notebook/notebookLogic.ts b/frontend/src/scenes/notebooks/Notebook/notebookLogic.ts
index 5b9396ecdc94b..bc0593c22bff3 100644
--- a/frontend/src/scenes/notebooks/Notebook/notebookLogic.ts
+++ b/frontend/src/scenes/notebooks/Notebook/notebookLogic.ts
@@ -232,6 +232,7 @@ export const notebookLogic = kea<notebookLogicType>([
                             content: null,
                             text_content: null,
                             version: 0,
+                            user_access_level: 'editor',
                         }
                     } else if (props.shortId.startsWith('template-')) {
                         response =
diff --git a/frontend/src/scenes/notebooks/NotebookTemplates/notebookTemplates.ts b/frontend/src/scenes/notebooks/NotebookTemplates/notebookTemplates.ts
index f1c63fe133674..7206f48eaf4a4 100644
--- a/frontend/src/scenes/notebooks/NotebookTemplates/notebookTemplates.ts
+++ b/frontend/src/scenes/notebooks/NotebookTemplates/notebookTemplates.ts
@@ -19,6 +19,7 @@ export const LOCAL_NOTEBOOK_TEMPLATES: NotebookType[] = [
         last_modified_at: '2023-06-02T00:00:00Z',
         created_by: TEMPLATE_USERS.posthog,
         last_modified_by: TEMPLATE_USERS.posthog,
+        user_access_level: 'viewer' as const,
         version: 1,
         content: {
             type: 'doc',
diff --git a/frontend/src/scenes/onboarding/Onboarding.tsx b/frontend/src/scenes/onboarding/Onboarding.tsx
index a4106a69173ad..ee905098856d8 100644
--- a/frontend/src/scenes/onboarding/Onboarding.tsx
+++ b/frontend/src/scenes/onboarding/Onboarding.tsx
@@ -120,7 +120,7 @@ const ProductAnalyticsOnboarding = (): JSX.Element => {
     const options: ProductConfigOption[] = [
         {
             title: 'Autocapture frontend interactions',
-            description: `If you use our JavaScript or React Native libraries, we'll automagically 
+            description: `If you use our JavaScript, React Native or iOS libraries, we'll automagically 
             capture frontend interactions like clicks, submits, and more. Fine-tune what you 
             capture directly in your code snippet.`,
             teamProperty: 'autocapture_opt_out',
@@ -199,7 +199,7 @@ const WebAnalyticsOnboarding = (): JSX.Element => {
     const options: ProductConfigOption[] = [
         {
             title: 'Autocapture frontend interactions',
-            description: `If you use our JavaScript or React Native libraries, we'll automagically 
+            description: `If you use our JavaScript, React Native or iOS libraries, we'll automagically 
             capture frontend interactions like clicks, submits, and more. Fine-tune what you 
             capture directly in your code snippet.`,
             teamProperty: 'autocapture_opt_out',
diff --git a/frontend/src/scenes/onboarding/sdks/feature-flags/flutter.tsx b/frontend/src/scenes/onboarding/sdks/feature-flags/flutter.tsx
index ac4e3750e6d6e..01c641837a24b 100644
--- a/frontend/src/scenes/onboarding/sdks/feature-flags/flutter.tsx
+++ b/frontend/src/scenes/onboarding/sdks/feature-flags/flutter.tsx
@@ -1,6 +1,7 @@
 import { SDKKey } from '~/types'
 
 import { SDKInstallFlutterInstructions } from '../sdk-install-instructions'
+import { AdvertiseMobileReplay } from '../session-replay/SessionReplaySDKInstructions'
 import { FlagImplementationSnippet } from './flagImplementationSnippet'
 
 export function FeatureFlagsFlutterInstructions(): JSX.Element {
@@ -8,6 +9,7 @@ export function FeatureFlagsFlutterInstructions(): JSX.Element {
         <>
             <SDKInstallFlutterInstructions />
             <FlagImplementationSnippet sdkKey={SDKKey.FLUTTER} />
+            <AdvertiseMobileReplay context="flags-onboarding" sdkKey={SDKKey.FLUTTER} />
         </>
     )
 }
diff --git a/frontend/src/scenes/onboarding/sdks/feature-flags/ios.tsx b/frontend/src/scenes/onboarding/sdks/feature-flags/ios.tsx
index 4ee24956e0564..a0416883f0667 100644
--- a/frontend/src/scenes/onboarding/sdks/feature-flags/ios.tsx
+++ b/frontend/src/scenes/onboarding/sdks/feature-flags/ios.tsx
@@ -9,7 +9,7 @@ export function FeatureFlagsIOSInstructions(): JSX.Element {
         <>
             <SDKInstallIOSInstructions />
             <FlagImplementationSnippet sdkKey={SDKKey.IOS} />
-            <AdvertiseMobileReplay context="product-analytics-onboarding" sdkKey={SDKKey.IOS} />
+            <AdvertiseMobileReplay context="flags-onboarding" sdkKey={SDKKey.IOS} />
         </>
     )
 }
diff --git a/frontend/src/scenes/onboarding/sdks/product-analytics/flutter.tsx b/frontend/src/scenes/onboarding/sdks/product-analytics/flutter.tsx
index aa02bdb26a604..e09f47ecbe5e1 100644
--- a/frontend/src/scenes/onboarding/sdks/product-analytics/flutter.tsx
+++ b/frontend/src/scenes/onboarding/sdks/product-analytics/flutter.tsx
@@ -1,6 +1,10 @@
 import { CodeSnippet, Language } from 'lib/components/CodeSnippet'
 
+import { SDKKey } from '~/types'
+
 import { SDKInstallFlutterInstructions } from '../sdk-install-instructions'
+import { AdvertiseMobileReplay } from '../session-replay/SessionReplaySDKInstructions'
+import { PersonModeEventPropertyInstructions } from '../shared-snippets'
 
 function FlutterCaptureSnippet(): JSX.Element {
     return (
@@ -18,6 +22,8 @@ export function ProductAnalyticsFlutterInstructions(): JSX.Element {
             <SDKInstallFlutterInstructions />
             <h3>Send an Event</h3>
             <FlutterCaptureSnippet />
+            <PersonModeEventPropertyInstructions />
+            <AdvertiseMobileReplay context="product-analytics-onboarding" sdkKey={SDKKey.FLUTTER} />
         </>
     )
 }
diff --git a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/android.tsx b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/android.tsx
index 20020ad69393a..76be40a10ca56 100644
--- a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/android.tsx
+++ b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/android.tsx
@@ -42,7 +42,7 @@ function AndroidSetupSnippet({ includeReplay }: AndroidSetupProps): JSX.Element
         ${
             includeReplay
                 ? `
-        // check https://posthog.com/docs/session-replay/android#installation
+        // check https://posthog.com/docs/session-replay/installation?tab=Android
         // for more config and to learn about how we capture sessions on mobile
         // and what to expect
         config.sessionReplay = true
diff --git a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/flutter.tsx b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/flutter.tsx
index e5164e93d378e..1017f86e4a4a6 100644
--- a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/flutter.tsx
+++ b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/flutter.tsx
@@ -1,17 +1,108 @@
+import { LemonBanner, Link } from '@posthog/lemon-ui'
 import { useValues } from 'kea'
 import { CodeSnippet, Language } from 'lib/components/CodeSnippet'
 import { useJsSnippet } from 'lib/components/JSSnippet'
 import { apiHostOrigin } from 'lib/utils/apiHost'
 import { teamLogic } from 'scenes/teamLogic'
 
+export interface FlutterSetupProps {
+    includeReplay?: boolean
+}
+
+export interface FlutterInstallProps {
+    apiToken?: string
+}
+
 function FlutterInstallSnippet(): JSX.Element {
     return <CodeSnippet language={Language.YAML}>posthog_flutter: ^4.0.0</CodeSnippet>
 }
 
-function FlutterAndroidSetupSnippet(): JSX.Element {
+function InstallFlutterSessionReplay(props: FlutterInstallProps): JSX.Element {
+    return (
+        <CodeSnippet language={Language.Dart}>
+            {`import 'package:flutter/material.dart';
+
+import 'package:posthog_flutter/posthog_flutter.dart';
+
+Future<void> main() async {
+  // init WidgetsFlutterBinding if not yet
+  WidgetsFlutterBinding.ensureInitialized();
+  final config = PostHogConfig('${props.apiToken}');
+  config.host = '${apiHostOrigin()}';
+  config.debug = true;
+  config.captureApplicationLifecycleEvents = true;
+
+  // check https://posthog.com/docs/session-replay/installation?tab=Flutter
+  // for more config and to learn about how we capture sessions on mobile
+  // and what to expect
+  config.sessionReplay = true;
+  // choose whether to mask images or text
+  config.sessionReplayConfig.maskAllTexts = false;
+  config.sessionReplayConfig.maskAllImages = false;
+
+  // Setup PostHog with the given Context and Config
+  await Posthog().setup(config);
+  runApp(MyApp());
+}`}
+        </CodeSnippet>
+    )
+}
+
+function InstallFlutterWidgetsSessionReplay(): JSX.Element {
+    return (
+        <CodeSnippet language={Language.Dart}>
+            {`import 'package:flutter/material.dart';
+
+import 'package:posthog_flutter/posthog_flutter.dart';
+
+class MyApp extends StatefulWidget {
+  const MyApp({super.key});
+
+  @override
+  State<MyApp> createState() => _MyAppState();
+}
+
+class _MyAppState extends State<MyApp> {
+  @override
+  void initState() {
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    // Wrap your App with PostHogWidget
+    return PostHogWidget(
+      child: MaterialApp(
+        // Add PosthogObserver to your navigatorObservers
+        navigatorObservers: [PosthogObserver()],
+        title: 'My App',
+        home: const HomeScreen(),
+      ),
+    );
+  }
+}`}
+        </CodeSnippet>
+    )
+}
+
+function FlutterAndroidSetupSnippet({ includeReplay }: FlutterSetupProps): JSX.Element {
     const { currentTeam } = useValues(teamLogic)
     const url = apiHostOrigin()
+    const props = { apiToken: currentTeam?.api_token }
 
+    if (includeReplay) {
+        return (
+            <>
+                <CodeSnippet language={Language.XML}>
+                    {
+                        '<application>\n\t<activity>\n\t\t[...]\n\t</activity>\n\t<meta-data android:name="com.posthog.posthog.AUTO_INIT" android:value="false" />\n</application>'
+                    }
+                </CodeSnippet>
+                <InstallFlutterSessionReplay {...props} />
+                <InstallFlutterWidgetsSessionReplay />
+            </>
+        )
+    }
     return (
         <CodeSnippet language={Language.XML}>
             {'<application>\n\t<activity>\n\t\t[...]\n\t</activity>\n\t<meta-data android:name="com.posthog.posthog.API_KEY" android:value="' +
@@ -23,10 +114,22 @@ function FlutterAndroidSetupSnippet(): JSX.Element {
     )
 }
 
-function FlutterIOSSetupSnippet(): JSX.Element {
+function FlutterIOSSetupSnippet({ includeReplay }: FlutterSetupProps): JSX.Element {
     const { currentTeam } = useValues(teamLogic)
     const url = apiHostOrigin()
+    const props = { apiToken: currentTeam?.api_token }
 
+    if (includeReplay) {
+        return (
+            <>
+                <CodeSnippet language={Language.XML}>
+                    {'<dict>\n\t[...]\n\t<key>com.posthog.posthog.AUTO_INIT</key>\n\t<false/>\n\t[...]\n</dict>'}
+                </CodeSnippet>
+                <InstallFlutterSessionReplay {...props} />
+                <InstallFlutterWidgetsSessionReplay />
+            </>
+        )
+    }
     return (
         <CodeSnippet language={Language.XML}>
             {'<dict>\n\t[...]\n\t<key>com.posthog.posthog.API_KEY</key>\n\t<string>' +
@@ -58,20 +161,54 @@ ${jsSnippet}
     )
 }
 
-export function SDKInstallFlutterInstructions(): JSX.Element {
+export function SDKInstallFlutterInstructions(props: FlutterSetupProps): JSX.Element {
     return (
         <>
+            {props.includeReplay ? (
+                <LemonBanner type="info">
+                    🚧 NOTE: <Link to="https://posthog.com/docs/session-replay/mobile">Mobile recording</Link> is
+                    currently in beta. We are keen to gather as much feedback as possible so if you try this out please
+                    let us know. You can send feedback via the{' '}
+                    <Link to="https://us.posthog.com/#panel=support%3Afeedback%3Asession_replay%3Alow">
+                        in-app support panel
+                    </Link>{' '}
+                    or one of our other <Link to="https://posthog.com/docs/support-options">support options</Link>.
+                </LemonBanner>
+            ) : null}
             <h3>Install</h3>
             <FlutterInstallSnippet />
             <h3>Android Setup</h3>
             <p className="prompt-text">Add these values in AndroidManifest.xml</p>
-            <FlutterAndroidSetupSnippet />
+            <FlutterAndroidSetupSnippet {...props} />
             <h3>iOS/macOS Setup</h3>
             <p className="prompt-text">Add these values in Info.plist</p>
-            <FlutterIOSSetupSnippet />
+            <FlutterIOSSetupSnippet {...props} />
             <h3>Web Setup</h3>
             <p className="prompt-text">Add these values in index.html</p>
             <FlutterWebSetupSnippet />
         </>
     )
 }
+
+export function SDKInstallFlutterTrackScreenInstructions(): JSX.Element {
+    return (
+        <>
+            <p>
+                With the <Link to="https://posthog.com/docs/libraries/flutter#example">PosthogObserver</Link> Observer,
+                PostHog will try to record all screen changes automatically.
+            </p>
+            <p>
+                If you want to manually send a new screen capture event, use the <code>screen</code> function.
+            </p>
+            <CodeSnippet language={Language.Dart}>{`import 'package:posthog_flutter/posthog_flutter.dart';
+
+await Posthog().screen(
+    screenName: 'Dashboard',
+    properties: {
+      'background': 'blue',
+      'hero': 'superhog'
+    });
+`}</CodeSnippet>
+        </>
+    )
+}
diff --git a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/ios.tsx b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/ios.tsx
index fdafc65560934..8f64d7c261ba7 100644
--- a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/ios.tsx
+++ b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/ios.tsx
@@ -40,7 +40,7 @@ class AppDelegate: NSObject, UIApplicationDelegate {
         ${
             includeReplay
                 ? `
-        // check https://posthog.com/docs/session-replay/ios#installation
+        // check https://posthog.com/docs/session-replay/installation?tab=iOS
         // for more config and to learn about how we capture sessions on mobile
         // and what to expect
         config.sessionReplay = true
diff --git a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/react-native.tsx b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/react-native.tsx
index 782fc947ba72f..f60c20c0c65ac 100644
--- a/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/react-native.tsx
+++ b/frontend/src/scenes/onboarding/sdks/sdk-install-instructions/react-native.tsx
@@ -58,6 +58,9 @@ export function MyApp() {
             ${
                 includeReplay
                     ? `
+            // check https://posthog.com/docs/session-replay/installation?tab=React+Native
+            // for more config and to learn about how we capture sessions on mobile
+            // and what to expect
             enableSessionReplay: true,
             sessionReplayConfig: {
                 // Whether text inputs are masked. Default is true.
diff --git a/frontend/src/scenes/onboarding/sdks/session-replay/SessionReplaySDKInstructions.tsx b/frontend/src/scenes/onboarding/sdks/session-replay/SessionReplaySDKInstructions.tsx
index 90629bcd6f691..29641d978af38 100644
--- a/frontend/src/scenes/onboarding/sdks/session-replay/SessionReplaySDKInstructions.tsx
+++ b/frontend/src/scenes/onboarding/sdks/session-replay/SessionReplaySDKInstructions.tsx
@@ -12,6 +12,7 @@ import {
     AngularInstructions,
     AstroInstructions,
     BubbleInstructions,
+    FlutterInstructions,
     FramerInstructions,
     HTMLSnippetInstructions,
     iOSInstructions,
@@ -20,11 +21,11 @@ import {
     NuxtJSInstructions,
     ReactInstructions,
     RemixInstructions,
+    RNInstructions,
     SvelteInstructions,
     VueInstructions,
     WebflowInstructions,
 } from '.'
-import { RNInstructions } from './react-native'
 
 export const SessionReplaySDKInstructions: SDKInstructionsMap = {
     [SDKKey.JS_WEB]: JSWebInstructions,
@@ -43,6 +44,7 @@ export const SessionReplaySDKInstructions: SDKInstructionsMap = {
     [SDKKey.IOS]: iOSInstructions,
     [SDKKey.ANDROID]: AndroidInstructions,
     [SDKKey.REACT_NATIVE]: RNInstructions,
+    [SDKKey.FLUTTER]: FlutterInstructions,
 }
 
 export function AdvertiseMobileReplay({
diff --git a/frontend/src/scenes/onboarding/sdks/session-replay/flutter.tsx b/frontend/src/scenes/onboarding/sdks/session-replay/flutter.tsx
new file mode 100644
index 0000000000000..b5a20645e256c
--- /dev/null
+++ b/frontend/src/scenes/onboarding/sdks/session-replay/flutter.tsx
@@ -0,0 +1,11 @@
+import { SDKInstallFlutterInstructions } from '../sdk-install-instructions'
+import { SessionReplayFinalSteps } from '../shared-snippets'
+
+export function FlutterInstructions(): JSX.Element {
+    return (
+        <>
+            <SDKInstallFlutterInstructions includeReplay={true} />
+            <SessionReplayFinalSteps />
+        </>
+    )
+}
diff --git a/frontend/src/scenes/onboarding/sdks/session-replay/index.tsx b/frontend/src/scenes/onboarding/sdks/session-replay/index.tsx
index 3a5aadfe8909d..a769433142bec 100644
--- a/frontend/src/scenes/onboarding/sdks/session-replay/index.tsx
+++ b/frontend/src/scenes/onboarding/sdks/session-replay/index.tsx
@@ -2,6 +2,7 @@ export * from './android'
 export * from './angular'
 export * from './astro'
 export * from './bubble'
+export * from './flutter'
 export * from './framer'
 export * from './html-snippet'
 export * from './ios'
@@ -9,6 +10,7 @@ export * from './js-web'
 export * from './next-js'
 export * from './nuxt'
 export * from './react'
+export * from './react-native'
 export * from './remix'
 export * from './svelte'
 export * from './vue'
diff --git a/frontend/src/scenes/onboarding/sdks/web-analytics/WebAnalyticsSDKInstructions.tsx b/frontend/src/scenes/onboarding/sdks/web-analytics/WebAnalyticsSDKInstructions.tsx
index e4778bd86bb43..4457c6dfb7b3d 100644
--- a/frontend/src/scenes/onboarding/sdks/web-analytics/WebAnalyticsSDKInstructions.tsx
+++ b/frontend/src/scenes/onboarding/sdks/web-analytics/WebAnalyticsSDKInstructions.tsx
@@ -5,6 +5,7 @@ import {
     AngularInstructions,
     AstroInstructions,
     BubbleInstructions,
+    FlutterInstructions,
     FramerInstructions,
     HTMLSnippetInstructions,
     iOSInstructions,
@@ -36,4 +37,5 @@ export const WebAnalyticsSDKInstructions: SDKInstructionsMap = {
     [SDKKey.WEBFLOW]: WebflowInstructions,
     [SDKKey.ANDROID]: AndroidInstructions,
     [SDKKey.REACT_NATIVE]: WebAnalyticsRNInstructions,
+    [SDKKey.FLUTTER]: FlutterInstructions,
 }
diff --git a/frontend/src/scenes/onboarding/sdks/web-analytics/flutter.tsx b/frontend/src/scenes/onboarding/sdks/web-analytics/flutter.tsx
new file mode 100644
index 0000000000000..7496820b35ad1
--- /dev/null
+++ b/frontend/src/scenes/onboarding/sdks/web-analytics/flutter.tsx
@@ -0,0 +1,13 @@
+import { WebAnalyticsMobileFinalSteps } from 'scenes/onboarding/sdks/web-analytics/FinalSteps'
+
+import { SDKInstallFlutterInstructions, SDKInstallFlutterTrackScreenInstructions } from '../sdk-install-instructions'
+
+export function FlutterInstructions(): JSX.Element {
+    return (
+        <>
+            <SDKInstallFlutterInstructions includeReplay={false} />
+            <WebAnalyticsMobileFinalSteps />
+            <SDKInstallFlutterTrackScreenInstructions />
+        </>
+    )
+}
diff --git a/frontend/src/scenes/onboarding/sdks/web-analytics/index.tsx b/frontend/src/scenes/onboarding/sdks/web-analytics/index.tsx
index 463169921abcb..a769433142bec 100644
--- a/frontend/src/scenes/onboarding/sdks/web-analytics/index.tsx
+++ b/frontend/src/scenes/onboarding/sdks/web-analytics/index.tsx
@@ -2,6 +2,7 @@ export * from './android'
 export * from './angular'
 export * from './astro'
 export * from './bubble'
+export * from './flutter'
 export * from './framer'
 export * from './html-snippet'
 export * from './ios'
diff --git a/frontend/src/scenes/persons/PersonScene.tsx b/frontend/src/scenes/persons/PersonScene.tsx
index d32f7ec107676..aa8e74a976266 100644
--- a/frontend/src/scenes/persons/PersonScene.tsx
+++ b/frontend/src/scenes/persons/PersonScene.tsx
@@ -7,11 +7,13 @@ import { NotFound } from 'lib/components/NotFound'
 import { PageHeader } from 'lib/components/PageHeader'
 import { PropertiesTable } from 'lib/components/PropertiesTable'
 import { TZLabel } from 'lib/components/TZLabel'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { groupsAccessLogic } from 'lib/introductions/groupsAccessLogic'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
 import { LemonTabs } from 'lib/lemon-ui/LemonTabs'
 import { SpinnerOverlay } from 'lib/lemon-ui/Spinner/Spinner'
 import { Tooltip } from 'lib/lemon-ui/Tooltip'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { copyToClipboard } from 'lib/utils/copyToClipboard'
 import { RelatedGroups } from 'scenes/groups/RelatedGroups'
 import { NotebookSelectButton } from 'scenes/notebooks/NotebookSelectButton/NotebookSelectButton'
@@ -106,6 +108,7 @@ export function PersonScene(): JSX.Element | null {
         splitMergeModalShown,
         urlId,
         distinctId,
+        primaryDistinctId,
     } = useValues(personsLogic)
     const { loadPersons, editProperty, deleteProperty, navigateToTab, setSplitMergeModalShown, setDistinctId } =
         useActions(personsLogic)
@@ -113,6 +116,7 @@ export function PersonScene(): JSX.Element | null {
     const { deletedPersonLoading } = useValues(personDeleteModalLogic)
     const { groupsEnabled } = useValues(groupsAccessLogic)
     const { currentTeam } = useValues(teamLogic)
+    const { featureFlags } = useValues(featureFlagLogic)
 
     if (personError) {
         throw new Error(personError)
@@ -122,6 +126,7 @@ export function PersonScene(): JSX.Element | null {
     }
 
     const url = urls.personByDistinctId(urlId || person.distinct_ids[0] || String(person.id))
+    const settingLevel = featureFlags[FEATURE_FLAGS.ENVIRONMENTS] ? 'environment' : 'project'
 
     return (
         <>
@@ -226,8 +231,8 @@ export function PersonScene(): JSX.Element | null {
                                 {!currentTeam?.session_recording_opt_in ? (
                                     <div className="mb-4">
                                         <LemonBanner type="info">
-                                            Session recordings are currently disabled for this project. To use this
-                                            feature, please go to your{' '}
+                                            Session recordings are currently disabled for this {settingLevel}. To use
+                                            this feature, please go to your{' '}
                                             <Link to={`${urls.settings('project')}#recordings`}>project settings</Link>{' '}
                                             and enable it.
                                         </LemonBanner>
@@ -293,7 +298,7 @@ export function PersonScene(): JSX.Element | null {
                                               </Tooltip>
                                           </div>
                                           <LemonSelect
-                                              value={distinctId || person.distinct_ids[0]}
+                                              value={distinctId || primaryDistinctId}
                                               onChange={(value) => value && setDistinctId(value)}
                                               options={person.distinct_ids.map((distinct_id) => ({
                                                   label: distinct_id,
diff --git a/frontend/src/scenes/persons/personsLogic.tsx b/frontend/src/scenes/persons/personsLogic.tsx
index 7d92c0593eb54..d408ec3a74ed0 100644
--- a/frontend/src/scenes/persons/personsLogic.tsx
+++ b/frontend/src/scenes/persons/personsLogic.tsx
@@ -286,6 +286,24 @@ export const personsLogic = kea<personsLogicType>([
             (featureFlags) => featureFlags[FEATURE_FLAGS.CS_DASHBOARDS],
         ],
         feedEnabled: [(s) => [s.featureFlags], (featureFlags) => !!featureFlags[FEATURE_FLAGS.PERSON_FEED_CANVAS]],
+        primaryDistinctId: [
+            (s) => [s.person],
+            (person): string | null => {
+                // We do not track which distinct ID was created through identify, but we can try to guess
+                const nonUuidDistinctIds = person?.distinct_ids.filter((id) => id?.split('-').length !== 5)
+
+                if (nonUuidDistinctIds && nonUuidDistinctIds?.length >= 1) {
+                    /**
+                     * If there are one or more distinct IDs that are not a UUID, one of them is most likely
+                     * the identified ID. In most cases, there would be only one non-UUID distinct ID.
+                     */
+                    return nonUuidDistinctIds[0]
+                }
+
+                // Otherwise, just fall back to the default first distinct ID
+                return person?.distinct_ids[0] || null
+            },
+        ],
     })),
     listeners(({ actions, values }) => ({
         editProperty: async ({ key, newValue }) => {
diff --git a/frontend/src/scenes/pipeline/Transformations.tsx b/frontend/src/scenes/pipeline/Transformations.tsx
index bd62e177b69f8..586e562f3a42c 100644
--- a/frontend/src/scenes/pipeline/Transformations.tsx
+++ b/frontend/src/scenes/pipeline/Transformations.tsx
@@ -4,6 +4,7 @@ import { arrayMove, SortableContext, useSortable, verticalListSortingStrategy }
 import { CSS } from '@dnd-kit/utilities'
 import { LemonBadge, LemonButton, LemonModal, LemonTable, LemonTableColumn, Link } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
+import { FlaggedFeature } from 'lib/components/FlaggedFeature'
 import { PageHeader } from 'lib/components/PageHeader'
 import { ProductIntroduction } from 'lib/components/ProductIntroduction/ProductIntroduction'
 import { More } from 'lib/lemon-ui/LemonButton/More'
@@ -14,6 +15,8 @@ import { urls } from 'scenes/urls'
 import { PipelineNodeTab, PipelineStage, ProductKey } from '~/types'
 
 import { AppMetricSparkLine } from './AppMetricSparkLine'
+import { TRANSFORMATION_TYPES } from './destinations/constants'
+import { Destinations } from './destinations/Destinations'
 import { NewButton } from './NewButton'
 import { pipelineAccessLogic } from './pipelineAccessLogic'
 import { PluginImage } from './PipelinePluginImage'
@@ -61,7 +64,13 @@ export function Transformations(): JSX.Element {
                     </div>
                 </>
             )}
+
             <TransformationsTable />
+
+            <FlaggedFeature flag="hog-transformations">
+                <h2 className="mt-4">Experimental transformations</h2>
+                <Destinations types={TRANSFORMATION_TYPES} />
+            </FlaggedFeature>
         </>
     )
 }
@@ -238,7 +247,7 @@ const MinimalAppView = ({ transformation, order }: { transformation: Transformat
     return (
         <div
             ref={setNodeRef}
-            className="flex gap-2 cursor-move border rounded p-2 items-center bg-bg-light relative"
+            className="relative flex items-center gap-2 p-2 border rounded cursor-move bg-bg-light"
             // eslint-disable-next-line react/forbid-dom-props
             style={{
                 transform: CSS.Transform.toString(transform),
diff --git a/frontend/src/scenes/pipeline/destinations/Destinations.tsx b/frontend/src/scenes/pipeline/destinations/Destinations.tsx
index 4f7e8cc4f37f5..9230d521b412e 100644
--- a/frontend/src/scenes/pipeline/destinations/Destinations.tsx
+++ b/frontend/src/scenes/pipeline/destinations/Destinations.tsx
@@ -19,7 +19,7 @@ import { hogFunctionTypeToPipelineStage } from '../hogfunctions/urls'
 import { AppMetricSparkLineV2 } from '../metrics/AppMetricsV2Sparkline'
 import { NewButton } from '../NewButton'
 import { pipelineAccessLogic } from '../pipelineAccessLogic'
-import { Destination, PipelineBackend, SiteApp } from '../types'
+import { Destination, PipelineBackend, SiteApp, Transformation } from '../types'
 import { pipelineNodeMenuCommonItems, RenderApp, RenderBatchExportIcon } from '../utils'
 import { DestinationsFilters } from './DestinationsFilters'
 import { destinationsFiltersLogic } from './destinationsFiltersLogic'
@@ -58,12 +58,7 @@ export function Destinations({ types }: DestinationsProps): JSX.Element {
                     caption="Run custom scripts on your website."
                     buttons={<NewButton stage={PipelineStage.SiteApp} />}
                 />
-            ) : (
-                <PageHeader
-                    caption="Run custom scripts on your website or send your data in real time or in batches to destinations outside of PostHog."
-                    buttons={<NewButton stage={PipelineStage.SiteApp} />}
-                />
-            )}
+            ) : null}
 
             <DestinationsTable types={types} />
             <div className="mt-4" />
@@ -72,7 +67,9 @@ export function Destinations({ types }: DestinationsProps): JSX.Element {
                     ? 'New destinations'
                     : types.includes('site_app')
                     ? 'New site app'
-                    : 'New Hog function'}
+                    : types.includes('transformation')
+                    ? 'New transformation'
+                    : 'New'}
             </h2>
             <DestinationOptionsTable types={types} />
             {/* Old site-apps until we migrate everyone onto the new ones */}
@@ -169,7 +166,7 @@ export function DestinationsTable({
                                   render: function RenderFrequency(_, destination) {
                                       return 'interval' in destination ? destination.interval : null
                                   },
-                              } as LemonTableColumn<Destination | SiteApp, any>,
+                              } as LemonTableColumn<Destination | Transformation | SiteApp, any>,
                           ]
                         : []),
                     ...(showFrequencyHistory
@@ -193,10 +190,10 @@ export function DestinationsTable({
                                           </Link>
                                       )
                                   },
-                              } as LemonTableColumn<Destination | SiteApp, any>,
+                              } as LemonTableColumn<Destination | Transformation | SiteApp, any>,
                           ]
                         : []),
-                    updatedAtColumn() as LemonTableColumn<Destination | SiteApp, any>,
+                    updatedAtColumn() as LemonTableColumn<Destination | Transformation | SiteApp, any>,
                     {
                         title: 'Status',
                         key: 'enabled',
diff --git a/frontend/src/scenes/pipeline/destinations/constants.ts b/frontend/src/scenes/pipeline/destinations/constants.ts
index dda2e7d0fe3d0..2d353802e5328 100644
--- a/frontend/src/scenes/pipeline/destinations/constants.ts
+++ b/frontend/src/scenes/pipeline/destinations/constants.ts
@@ -2,3 +2,4 @@ import { HogFunctionTypeType } from '~/types'
 
 export const DESTINATION_TYPES = ['destination', 'site_destination'] satisfies HogFunctionTypeType[]
 export const SITE_APP_TYPES = ['site_app'] satisfies HogFunctionTypeType[]
+export const TRANSFORMATION_TYPES = ['transformation'] satisfies HogFunctionTypeType[]
diff --git a/frontend/src/scenes/pipeline/destinations/destinationsLogic.tsx b/frontend/src/scenes/pipeline/destinations/destinationsLogic.tsx
index bed880c886729..ea6bf3346687c 100644
--- a/frontend/src/scenes/pipeline/destinations/destinationsLogic.tsx
+++ b/frontend/src/scenes/pipeline/destinations/destinationsLogic.tsx
@@ -20,6 +20,7 @@ import {
     PluginType,
 } from '~/types'
 
+import { hogFunctionTypeToPipelineStage } from '../hogfunctions/urls'
 import { pipelineAccessLogic } from '../pipelineAccessLogic'
 import {
     BatchExportDestination,
@@ -28,6 +29,7 @@ import {
     FunctionDestination,
     PipelineBackend,
     SiteApp,
+    Transformation,
     WebhookDestination,
 } from '../types'
 import { captureBatchExportEvent, capturePluginEvent, loadPluginsFromUrl } from '../utils'
@@ -35,7 +37,7 @@ import { destinationsFiltersLogic } from './destinationsFiltersLogic'
 import type { pipelineDestinationsLogicType } from './destinationsLogicType'
 
 // Helping kea-typegen navigate the exported default class for Fuse
-export interface Fuse extends FuseClass<Destination | SiteApp> {}
+export interface Fuse extends FuseClass<Destination | Transformation | SiteApp> {}
 
 export interface PipelineDestinationsLogicProps {
     types: HogFunctionTypeType[]
@@ -60,9 +62,12 @@ export const pipelineDestinationsLogic = kea<pipelineDestinationsLogicType>([
         ],
     })),
     actions({
-        toggleNode: (destination: Destination | SiteApp, enabled: boolean) => ({ destination, enabled }),
+        toggleNode: (destination: Destination | SiteApp | Transformation, enabled: boolean) => ({
+            destination,
+            enabled,
+        }),
         toggleNodeHogFunction: (destination: FunctionDestination, enabled: boolean) => ({ destination, enabled }),
-        deleteNode: (destination: Destination | SiteApp) => ({ destination }),
+        deleteNode: (destination: Destination | SiteApp | Transformation) => ({ destination }),
         deleteNodeBatchExport: (destination: BatchExportDestination) => ({ destination }),
         deleteNodeHogFunction: (destination: FunctionDestination) => ({ destination }),
         deleteNodeWebhook: (destination: WebhookDestination) => ({ destination }),
@@ -240,7 +245,7 @@ export const pipelineDestinationsLogic = kea<pipelineDestinationsLogicType>([
                 hogFunctions,
                 user,
                 featureFlags
-            ): (Destination | SiteApp)[] => {
+            ): (Destination | Transformation | SiteApp)[] => {
                 // Migrations are shown only in impersonation mode, for us to be able to trigger them.
                 const httpEnabled =
                     featureFlags[FEATURE_FLAGS.BATCH_EXPORTS_POSTHOG_HTTP] || user?.is_impersonated || user?.is_staff
@@ -262,7 +267,7 @@ export const pipelineDestinationsLogic = kea<pipelineDestinationsLogicType>([
                 const convertedDestinations = rawDestinations.map((d) =>
                     convertToPipelineNode(
                         d,
-                        'type' in d && d.type === 'site_app' ? PipelineStage.SiteApp : PipelineStage.Destination
+                        'type' in d ? hogFunctionTypeToPipelineStage(d.type) : PipelineStage.Destination
                     )
                 )
                 const enabledFirst = convertedDestinations.sort((a, b) => Number(b.enabled) - Number(a.enabled))
@@ -281,7 +286,7 @@ export const pipelineDestinationsLogic = kea<pipelineDestinationsLogicType>([
 
         filteredDestinations: [
             (s) => [s.filters, s.destinations, s.destinationsFuse],
-            (filters, destinations, destinationsFuse): (Destination | SiteApp)[] => {
+            (filters, destinations, destinationsFuse): (Destination | Transformation | SiteApp)[] => {
                 const { search, showPaused, kind } = filters
 
                 return (search ? destinationsFuse.search(search).map((x) => x.item) : destinations).filter((dest) => {
@@ -298,7 +303,7 @@ export const pipelineDestinationsLogic = kea<pipelineDestinationsLogicType>([
 
         hiddenDestinations: [
             (s) => [s.destinations, s.filteredDestinations],
-            (destinations, filteredDestinations): (Destination | SiteApp)[] => {
+            (destinations, filteredDestinations): (Destination | Transformation | SiteApp)[] => {
                 return destinations.filter((dest) => !filteredDestinations.includes(dest))
             },
         ],
@@ -320,7 +325,8 @@ export const pipelineDestinationsLogic = kea<pipelineDestinationsLogicType>([
         deleteNode: ({ destination }) => {
             switch (destination.backend) {
                 case PipelineBackend.Plugin:
-                    actions.deleteNodeWebhook(destination as WebhookDestination)
+                    // @ts-expect-error - type coercion is ignored, siteApps are just missing the interval prop
+                    actions.deleteNodeWebhook(destination)
                     break
                 case PipelineBackend.BatchExport:
                     actions.deleteNodeBatchExport(destination)
@@ -332,10 +338,12 @@ export const pipelineDestinationsLogic = kea<pipelineDestinationsLogicType>([
         },
     })),
 
-    afterMount(({ actions }) => {
+    afterMount(({ actions, props }) => {
         actions.loadPlugins()
         actions.loadPluginConfigs()
-        actions.loadBatchExports()
+        if (props.types.includes('destination')) {
+            actions.loadBatchExports()
+        }
         actions.loadHogFunctions()
     }),
 ])
diff --git a/frontend/src/scenes/pipeline/hogfunctions/HogFunctionConfiguration.tsx b/frontend/src/scenes/pipeline/hogfunctions/HogFunctionConfiguration.tsx
index f837bc49fe7b3..cfa5dc06d463c 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/HogFunctionConfiguration.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/HogFunctionConfiguration.tsx
@@ -35,6 +35,7 @@ import { HogFunctionIconEditable } from './HogFunctionIcon'
 import { HogFunctionInputs } from './HogFunctionInputs'
 import { HogFunctionStatusIndicator } from './HogFunctionStatusIndicator'
 import { HogFunctionTest, HogFunctionTestPlaceholder } from './HogFunctionTest'
+import { HogFunctionMapping } from './mapping/HogFunctionMapping'
 
 const EVENT_THRESHOLD_ALERT_LEVEL = 8000
 
@@ -151,14 +152,13 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
         return <PayGateMini feature={AvailableFeature.DATA_PIPELINES} />
     }
 
-    const showFilters = type === 'destination' || type === 'site_destination' || type === 'broadcast'
-    const showExpectedVolume = type === 'destination' || type === 'site_destination'
-    const showStatus = type === 'destination' || type === 'email'
-    const showEnabled = type === 'destination' || type === 'email' || type === 'site_destination' || type === 'site_app'
-    const canEditSource =
-        type === 'destination' || type === 'email' || type === 'site_destination' || type === 'site_app'
-    const showPersonsCount = type === 'broadcast'
-    const showTesting = type === 'destination' || type === 'broadcast' || type === 'email'
+    const showFilters = ['destination', 'site_destination', 'broadcast', 'transformation'].includes(type)
+    const showExpectedVolume = ['destination', 'site_destination'].includes(type)
+    const showStatus = ['destination', 'email', 'transformation'].includes(type)
+    const showEnabled = ['destination', 'email', 'site_destination', 'site_app', 'transformation'].includes(type)
+    const canEditSource = ['destination', 'email', 'site_destination', 'site_app', 'transformation'].includes(type)
+    const showPersonsCount = ['broadcast'].includes(type)
+    const showTesting = ['destination', 'transformation', 'broadcast', 'email'].includes(type)
 
     return (
         <div className="space-y-3">
@@ -194,10 +194,10 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                     formKey="configuration"
                     className="space-y-3"
                 >
-                    <div className="flex flex-wrap gap-4 items-start">
-                        <div className="flex flex-col gap-4 flex-1 min-w-100">
-                            <div className="border bg-bg-light rounded p-3 space-y-2">
-                                <div className="flex flex-row gap-2 min-h-16 items-center">
+                    <div className="flex flex-wrap items-start gap-4">
+                        <div className="flex flex-col flex-1 gap-4 min-w-100">
+                            <div className="p-3 space-y-2 border rounded bg-bg-light">
+                                <div className="flex flex-row items-center gap-2 min-h-16">
                                     <LemonField name="icon_url">
                                         {({ value, onChange }) => (
                                             <HogFunctionIconEditable
@@ -208,7 +208,7 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                         )}
                                     </LemonField>
 
-                                    <div className="flex flex-col items-start py-1 flex-1 justify-start">
+                                    <div className="flex flex-col items-start justify-start flex-1 py-1">
                                         <span className="font-semibold">{configuration.name}</span>
                                         {template && <DestinationTag status={template.status} />}
                                     </div>
@@ -243,14 +243,14 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                     <LemonDropdown
                                         showArrow
                                         overlay={
-                                            <div className="max-w-120 p-1">
+                                            <div className="p-1 max-w-120">
                                                 <p>
                                                     This function was built from the template{' '}
                                                     <b>{hogFunction.template.name}</b>. If the template is updated, this
                                                     function is not affected unless you choose to update it.
                                                 </p>
 
-                                                <div className="flex flex-1 gap-2 items-center border-t pt-2">
+                                                <div className="flex items-center flex-1 gap-2 pt-2 border-t">
                                                     <div className="flex-1">
                                                         <LemonButton>Close</LemonButton>
                                                     </div>
@@ -271,8 +271,8 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                             </div>
                                         }
                                     >
-                                        <div className="border border-dashed rounded text-muted-alt text-xs">
-                                            <Link subtle className="flex items-center gap-1 flex-wrap p-2">
+                                        <div className="text-xs border border-dashed rounded text-muted-alt">
+                                            <Link subtle className="flex flex-wrap items-center gap-1 p-2">
                                                 Built from template:
                                                 <span className="font-semibold">{hogFunction?.template.name}</span>
                                                 <DestinationTag status={hogFunction.template.status} />
@@ -288,7 +288,7 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                             {showFilters && <HogFunctionFilters />}
 
                             {showPersonsCount && (
-                                <div className="relative border bg-bg-light rounded p-3 space-y-2">
+                                <div className="relative p-3 space-y-2 border rounded bg-bg-light">
                                     <div>
                                         <LemonLabel>Matching persons</LemonLabel>
                                     </div>
@@ -318,7 +318,7 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                             )}
 
                             {showExpectedVolume && (
-                                <div className="relative border bg-bg-light rounded p-3 space-y-2">
+                                <div className="relative p-3 space-y-2 border rounded bg-bg-light">
                                     <LemonLabel>Expected volume</LemonLabel>
                                     {sparkline && !sparklineLoading ? (
                                         <>
@@ -358,10 +358,10 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                             )}
                         </div>
 
-                        <div className="flex-2 min-w-100 space-y-4">
+                        <div className="space-y-4 flex-2 min-w-100">
                             {!forcedSubTemplateId && template?.sub_templates && (
                                 <>
-                                    <div className="border bg-bg-light rounded p-3 space-y-2">
+                                    <div className="p-3 space-y-2 border rounded bg-bg-light">
                                         <div className="flex items-center gap-2">
                                             <LemonLabel className="flex-1">Choose template</LemonLabel>
                                             <LemonSelect
@@ -375,9 +375,9 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                                         value: subTemplate.id,
                                                         label: subTemplate.name,
                                                         labelInMenu: (
-                                                            <div className="max-w-120 space-y-1 my-1">
+                                                            <div className="my-1 space-y-1 max-w-120">
                                                                 <div className="font-semibold">{subTemplate.name}</div>
-                                                                <div className="text-muted font-sans text-xs">
+                                                                <div className="font-sans text-xs text-muted">
                                                                     {subTemplate.description}
                                                                 </div>
                                                             </div>
@@ -394,9 +394,12 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                 </>
                             )}
 
-                            <div className="border bg-bg-light rounded p-3 space-y-2">
+                            <div className="p-3 space-y-2 border rounded bg-bg-light">
                                 <div className="space-y-2">
-                                    <HogFunctionInputs />
+                                    <HogFunctionInputs
+                                        configuration={configuration}
+                                        setConfigurationValue={setConfigurationValue}
+                                    />
                                     {showSource && canEditSource ? (
                                         <LemonButton
                                             icon={<IconPlus />}
@@ -421,6 +424,8 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                 </div>
                             </div>
 
+                            <HogFunctionMapping />
+
                             {canEditSource && (
                                 <div
                                     className={clsx(
@@ -428,7 +433,7 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                         showSource ? 'bg-bg-light' : 'bg-accent-3000'
                                     )}
                                 >
-                                    <div className="flex items-center gap-2 justify-end">
+                                    <div className="flex items-center justify-end gap-2">
                                         <div className="flex-1 space-y-2">
                                             <h2 className="mb-0">Edit source</h2>
                                             {!showSource ? <p>Click here to edit the function's source code</p> : null}
@@ -501,7 +506,7 @@ export function HogFunctionConfiguration({ templateId, id }: HogFunctionConfigur
                                     <HogFunctionTest id={id} />
                                 )
                             ) : null}
-                            <div className="flex gap-2 justify-end">{saveButtons}</div>
+                            <div className="flex justify-end gap-2">{saveButtons}</div>
                         </div>
                     </div>
                 </Form>
diff --git a/frontend/src/scenes/pipeline/hogfunctions/HogFunctionInputs.tsx b/frontend/src/scenes/pipeline/hogfunctions/HogFunctionInputs.tsx
index 31dc8190bfc63..8cbb21044fc1a 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/HogFunctionInputs.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/HogFunctionInputs.tsx
@@ -14,14 +14,19 @@ import {
     LemonTextArea,
     Tooltip,
 } from '@posthog/lemon-ui'
-import { useActions, useValues } from 'kea'
+import { useValues } from 'kea'
 import { LemonField } from 'lib/lemon-ui/LemonField'
 import { CodeEditorInline, CodeEditorInlineProps } from 'lib/monaco/CodeEditorInline'
 import { CodeEditorResizeable } from 'lib/monaco/CodeEditorResizable'
 import { capitalizeFirstLetter } from 'lib/utils'
 import { useEffect, useState } from 'react'
 
-import { HogFunctionInputSchemaType, HogFunctionInputType } from '~/types'
+import {
+    HogFunctionConfigurationType,
+    HogFunctionInputSchemaType,
+    HogFunctionInputType,
+    HogFunctionMappingType,
+} from '~/types'
 
 import { EmailTemplater } from './email-templater/EmailTemplater'
 import { hogFunctionConfigurationLogic } from './hogFunctionConfigurationLogic'
@@ -35,7 +40,14 @@ export type HogFunctionInputProps = {
     disabled?: boolean
 }
 
+export interface HogFunctionInputsProps {
+    configuration: HogFunctionConfigurationType | HogFunctionMappingType
+    setConfigurationValue: (key: string, value: any) => void
+}
+
 export type HogFunctionInputWithSchemaProps = {
+    configuration: HogFunctionConfigurationType | HogFunctionMappingType
+    setConfigurationValue: (key: string, value: any) => void
     schema: HogFunctionInputSchemaType
 }
 
@@ -196,14 +208,25 @@ type HogFunctionInputSchemaControlsProps = {
     value: HogFunctionInputSchemaType
     onChange: (value: HogFunctionInputSchemaType | null) => void
     onDone: () => void
+    supportsSecrets: boolean
 }
 
-function HogFunctionInputSchemaControls({ value, onChange, onDone }: HogFunctionInputSchemaControlsProps): JSX.Element {
+function HogFunctionInputSchemaControls({
+    value,
+    onChange,
+    onDone,
+    supportsSecrets,
+}: HogFunctionInputSchemaControlsProps): JSX.Element {
     const _onChange = (data: Partial<HogFunctionInputSchemaType> | null): void => {
+        if (data?.key?.length === 0) {
+            setLocalVariableError('Input variable name cannot be empty')
+            return
+        }
         onChange(data ? { ...value, ...data } : null)
     }
 
     const [localVariableValue, setLocalVariableValue] = useState(value.key)
+    const [localVariableError, setLocalVariableError] = useState<string | null>(null)
 
     return (
         <div className="flex flex-col gap-2">
@@ -225,13 +248,15 @@ function HogFunctionInputSchemaControls({ value, onChange, onDone }: HogFunction
                     label="Required"
                     bordered
                 />
-                <LemonCheckbox
-                    size="small"
-                    checked={value.secret}
-                    onChange={(secret) => _onChange({ secret })}
-                    label="Secret"
-                    bordered
-                />
+                {supportsSecrets ? (
+                    <LemonCheckbox
+                        size="small"
+                        checked={value.secret}
+                        onChange={(secret) => _onChange({ secret })}
+                        label="Secret"
+                        bordered
+                    />
+                ) : null}
                 <div className="flex-1" />
                 <LemonButton status="danger" icon={<IconTrash />} size="small" onClick={() => onChange(null)} />
                 <LemonButton type="secondary" size="small" onClick={() => onDone()}>
@@ -248,7 +273,7 @@ function HogFunctionInputSchemaControls({ value, onChange, onDone }: HogFunction
                         placeholder="Display label"
                     />
                 </LemonField.Pure>
-                <LemonField.Pure label="Input variable name">
+                <LemonField.Pure label="Input variable name" error={localVariableError}>
                     <LemonInput
                         size="small"
                         value={localVariableValue}
@@ -309,10 +334,13 @@ function HogFunctionInputSchemaControls({ value, onChange, onDone }: HogFunction
     )
 }
 
-export function HogFunctionInputWithSchema({ schema }: HogFunctionInputWithSchemaProps): JSX.Element {
+export function HogFunctionInputWithSchema({
+    schema,
+    configuration,
+    setConfigurationValue,
+}: HogFunctionInputWithSchemaProps): JSX.Element {
     const { attributes, listeners, setNodeRef, transform, transition } = useSortable({ id: schema.key })
-    const { showSource, configuration } = useValues(hogFunctionConfigurationLogic)
-    const { setConfigurationValue } = useActions(hogFunctionConfigurationLogic)
+    const { showSource } = useValues(hogFunctionConfigurationLogic)
     const [editing, setEditing] = useState(false)
 
     const value = configuration.inputs?.[schema.key]
@@ -344,6 +372,7 @@ export function HogFunctionInputWithSchema({ schema }: HogFunctionInputWithSchem
     }, [showSource])
 
     const supportsTemplating = ['string', 'json', 'dictionary', 'email'].includes(schema.type)
+    const supportsSecrets = 'type' in configuration // no secrets for mapping inputs
 
     return (
         <div
@@ -439,6 +468,7 @@ export function HogFunctionInputWithSchema({ schema }: HogFunctionInputWithSchem
                         value={schema}
                         onChange={onSchemaChange}
                         onDone={() => setEditing(false)}
+                        supportsSecrets={supportsSecrets}
                     />
                 </div>
             )}
@@ -446,11 +476,17 @@ export function HogFunctionInputWithSchema({ schema }: HogFunctionInputWithSchem
     )
 }
 
-export function HogFunctionInputs(): JSX.Element {
-    const { showSource, configuration } = useValues(hogFunctionConfigurationLogic)
-    const { setConfigurationValue } = useActions(hogFunctionConfigurationLogic)
+export function HogFunctionInputs({
+    configuration,
+    setConfigurationValue,
+}: HogFunctionInputsProps): JSX.Element | null {
+    const { showSource } = useValues(hogFunctionConfigurationLogic)
 
     if (!configuration?.inputs_schema?.length) {
+        if (!('type' in configuration)) {
+            // If this is a mapping, don't show any error message.
+            return null
+        }
         return <span className="italic text-muted-alt">This function does not require any input variables.</span>
     }
 
@@ -472,7 +508,14 @@ export function HogFunctionInputs(): JSX.Element {
             >
                 <SortableContext disabled={!showSource} items={inputSchemaIds} strategy={verticalListSortingStrategy}>
                     {configuration.inputs_schema?.map((schema) => {
-                        return <HogFunctionInputWithSchema key={schema.key} schema={schema} />
+                        return (
+                            <HogFunctionInputWithSchema
+                                key={schema.key}
+                                schema={schema}
+                                configuration={configuration}
+                                setConfigurationValue={setConfigurationValue}
+                            />
+                        )
                     })}
                 </SortableContext>
             </DndContext>
diff --git a/frontend/src/scenes/pipeline/hogfunctions/HogFunctionTest.tsx b/frontend/src/scenes/pipeline/hogfunctions/HogFunctionTest.tsx
index db83344bcbcf1..1861b06f369ed 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/HogFunctionTest.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/HogFunctionTest.tsx
@@ -102,16 +102,14 @@ export function HogFunctionTest(props: HogFunctionTestLogicProps): JSX.Element {
                                 </LemonButton>
                             ) : (
                                 <>
-                                    {type === 'destination' ? (
-                                        <LemonButton
-                                            type="secondary"
-                                            onClick={loadSampleGlobals}
-                                            loading={sampleGlobalsLoading}
-                                            tooltip="Find the last event matching filters, and use it to populate the globals below."
-                                        >
-                                            Refresh globals
-                                        </LemonButton>
-                                    ) : null}
+                                    <LemonButton
+                                        type="secondary"
+                                        onClick={loadSampleGlobals}
+                                        loading={sampleGlobalsLoading}
+                                        tooltip="Find the last event matching filters, and use it to populate the globals below."
+                                    >
+                                        Refresh globals
+                                    </LemonButton>
                                     <LemonField name="mock_async_functions">
                                         {({ value, onChange }) => (
                                             <LemonSwitch
diff --git a/frontend/src/scenes/pipeline/hogfunctions/filters/HogFunctionFilters.tsx b/frontend/src/scenes/pipeline/hogfunctions/filters/HogFunctionFilters.tsx
index 1dd5588045f54..2c29f63794a3e 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/filters/HogFunctionFilters.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/filters/HogFunctionFilters.tsx
@@ -1,4 +1,4 @@
-import { LemonLabel, LemonSelect } from '@posthog/lemon-ui'
+import { LemonBanner, LemonLabel, LemonSelect, LemonSwitch } from '@posthog/lemon-ui'
 import { id } from 'chartjs-plugin-trendline'
 import { useValues } from 'kea'
 import { PropertyFilters } from 'lib/components/PropertyFilters/PropertyFilters'
@@ -45,11 +45,11 @@ function sanitizeActionFilters(filters?: FilterType): Partial<HogFunctionFilters
 
 export function HogFunctionFilters(): JSX.Element {
     const { groupsTaxonomicTypes } = useValues(groupsModel)
-    const { configuration, type } = useValues(hogFunctionConfigurationLogic)
+    const { configuration, type, useMapping } = useValues(hogFunctionConfigurationLogic)
 
     if (type === 'broadcast') {
         return (
-            <div className="border bg-bg-light rounded p-3 space-y-2">
+            <div className="p-3 space-y-2 border rounded bg-bg-light">
                 <LemonField name="filters" label="Filters">
                     {({ value, onChange }) => (
                         <PropertyFilters
@@ -75,81 +75,122 @@ export function HogFunctionFilters(): JSX.Element {
     }
 
     const showMasking = type === 'destination'
+    const showDropEvents = type === 'transformation'
 
     return (
-        <div className="border bg-bg-light rounded p-3 space-y-2">
-            <LemonField name="filters" label="Filters">
-                {({ value, onChange }) => (
-                    <>
-                        <TestAccountFilterSwitch
-                            checked={value?.filter_test_accounts ?? false}
-                            onChange={(filter_test_accounts) => onChange({ ...value, filter_test_accounts })}
-                            fullWidth
-                        />
-                        <PropertyFilters
-                            propertyFilters={value?.properties ?? []}
-                            taxonomicGroupTypes={[
-                                TaxonomicFilterGroupType.EventProperties,
-                                TaxonomicFilterGroupType.PersonProperties,
-                                TaxonomicFilterGroupType.EventFeatureFlags,
-                                TaxonomicFilterGroupType.Elements,
-                                TaxonomicFilterGroupType.HogQLExpression,
-                            ]}
-                            onChange={(properties: AnyPropertyFilter[]) => {
-                                onChange({
-                                    ...value,
-                                    properties,
-                                })
-                            }}
-                            pageKey={`HogFunctionPropertyFilters.${id}`}
-                        />
+        <div className="p-3 space-y-2 border rounded bg-bg-light">
+            <LemonField
+                name="filters"
+                label={useMapping ? 'Global filters' : 'Filters'}
+                info={useMapping ? 'Filters applied to all events before they reach a mapping' : null}
+            >
+                {({ value, onChange }) => {
+                    const filters = (value ?? {}) as HogFunctionFiltersType
+                    return (
+                        <>
+                            <TestAccountFilterSwitch
+                                checked={filters?.filter_test_accounts ?? false}
+                                onChange={(filter_test_accounts) => onChange({ ...filters, filter_test_accounts })}
+                                fullWidth
+                            />
+                            <PropertyFilters
+                                propertyFilters={(filters?.properties ?? []) as AnyPropertyFilter[]}
+                                taxonomicGroupTypes={[
+                                    TaxonomicFilterGroupType.EventProperties,
+                                    TaxonomicFilterGroupType.PersonProperties,
+                                    TaxonomicFilterGroupType.EventFeatureFlags,
+                                    TaxonomicFilterGroupType.Elements,
+                                    TaxonomicFilterGroupType.HogQLExpression,
+                                ]}
+                                onChange={(properties: AnyPropertyFilter[]) => {
+                                    onChange({
+                                        ...filters,
+                                        properties,
+                                    })
+                                }}
+                                pageKey={`HogFunctionPropertyFilters.${id}`}
+                            />
 
-                        <LemonLabel>Match event and actions</LemonLabel>
-                        <p className="mb-0 text-muted-alt text-xs">
-                            If set, the destination will only run if the <b>event matches any</b> of the below.
-                        </p>
-                        <ActionFilter
-                            bordered
-                            filters={value ?? {}}
-                            setFilters={(payload) => {
-                                onChange({
-                                    ...value,
-                                    ...sanitizeActionFilters(payload),
-                                })
-                            }}
-                            typeKey="plugin-filters"
-                            mathAvailability={MathAvailability.None}
-                            hideRename
-                            hideDuplicate
-                            showNestedArrow={false}
-                            actionsTaxonomicGroupTypes={[
-                                TaxonomicFilterGroupType.Events,
-                                TaxonomicFilterGroupType.Actions,
-                            ]}
-                            propertiesTaxonomicGroupTypes={[
-                                TaxonomicFilterGroupType.EventProperties,
-                                TaxonomicFilterGroupType.EventFeatureFlags,
-                                TaxonomicFilterGroupType.Elements,
-                                TaxonomicFilterGroupType.PersonProperties,
-                                TaxonomicFilterGroupType.HogQLExpression,
-                                ...groupsTaxonomicTypes,
-                            ]}
-                            propertyFiltersPopover
-                            addFilterDefaultOptions={{
-                                id: '$pageview',
-                                name: '$pageview',
-                                type: EntityTypes.EVENTS,
-                            }}
-                            buttonCopy="Add event matcher"
-                        />
-                    </>
-                )}
-            </LemonField>
+                            {!useMapping ? (
+                                <>
+                                    <div className="flex justify-between w-full gap-2">
+                                        <LemonLabel>Match events and actions</LemonLabel>
+                                    </div>
+                                    <p className="mb-0 text-xs text-muted-alt">
+                                        If set, the destination will only run if the <b>event matches any</b> of the
+                                        below.
+                                    </p>
+                                    <ActionFilter
+                                        bordered
+                                        filters={value ?? {} /* TODO: this is any */}
+                                        setFilters={(payload) => {
+                                            onChange({
+                                                ...value,
+                                                ...sanitizeActionFilters(payload),
+                                            })
+                                        }}
+                                        typeKey="plugin-filters"
+                                        mathAvailability={MathAvailability.None}
+                                        hideRename
+                                        hideDuplicate
+                                        showNestedArrow={false}
+                                        actionsTaxonomicGroupTypes={[
+                                            TaxonomicFilterGroupType.Events,
+                                            TaxonomicFilterGroupType.Actions,
+                                        ]}
+                                        propertiesTaxonomicGroupTypes={[
+                                            TaxonomicFilterGroupType.EventProperties,
+                                            TaxonomicFilterGroupType.EventFeatureFlags,
+                                            TaxonomicFilterGroupType.Elements,
+                                            TaxonomicFilterGroupType.PersonProperties,
+                                            TaxonomicFilterGroupType.HogQLExpression,
+                                            ...groupsTaxonomicTypes,
+                                        ]}
+                                        propertyFiltersPopover
+                                        addFilterDefaultOptions={{
+                                            id: '$pageview',
+                                            name: '$pageview',
+                                            type: EntityTypes.EVENTS,
+                                        }}
+                                        buttonCopy="Add event matcher"
+                                    />
 
+                                    {showDropEvents && (
+                                        <>
+                                            <LemonLabel>
+                                                <span className="flex items-center justify-between flex-1 gap-2">
+                                                    Drop events that don't match
+                                                    <LemonSwitch
+                                                        checked={value?.drop_events ?? false}
+                                                        onChange={(drop_events) => onChange({ ...value, drop_events })}
+                                                    />
+                                                </span>
+                                            </LemonLabel>
+
+                                            {!value?.drop_events ? (
+                                                <p>
+                                                    Currently, this will run for all events that match the above
+                                                    conditions. Any that do not match will be unmodified and ingested as
+                                                    they are.
+                                                </p>
+                                            ) : (
+                                                <LemonBanner type="error">
+                                                    This will drop all events that don't match the above conditions.
+                                                    Please ensure this is definitely intended.
+                                                </LemonBanner>
+                                            )}
+                                        </>
+                                    )}
+                                </>
+                            ) : null}
+                        </>
+                    )
+                }}
+            </LemonField>
             {showMasking ? (
                 <LemonField name="masking" label="Trigger options">
                     {({ value, onChange }) => (
-                        <div className="flex items-center gap-1 flex-wrap">
+                        <div className="flex flex-wrap items-center gap-1">
                             <LemonSelect
                                 options={[
                                     {
@@ -179,7 +220,7 @@ export function HogFunctionFilters(): JSX.Element {
                             />
                             {configuration.masking?.hash ? (
                                 <>
-                                    <div className="flex items-center gap-1 flex-wrap">
+                                    <div className="flex flex-wrap items-center gap-1">
                                         <span>of</span>
                                         <LemonSelect
                                             value={value?.ttl}
@@ -224,7 +265,7 @@ export function HogFunctionFilters(): JSX.Element {
                                             ]}
                                         />
                                     </div>
-                                    <div className="flex items-center gap-1 flex-wrap">
+                                    <div className="flex flex-wrap items-center gap-1">
                                         <span>or until</span>
                                         <LemonSelect
                                             value={value?.threshold}
diff --git a/frontend/src/scenes/pipeline/hogfunctions/hogFunctionConfigurationLogic.tsx b/frontend/src/scenes/pipeline/hogfunctions/hogFunctionConfigurationLogic.tsx
index 229abea7e424d..d6f7c98884a7c 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/hogFunctionConfigurationLogic.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/hogFunctionConfigurationLogic.tsx
@@ -29,12 +29,15 @@ import {
     EventType,
     FilterLogicalOperator,
     HogFunctionConfigurationType,
+    HogFunctionInputSchemaType,
     HogFunctionInputType,
     HogFunctionInvocationGlobals,
+    HogFunctionMappingType,
     HogFunctionSubTemplateIdType,
     HogFunctionSubTemplateType,
     HogFunctionTemplateType,
     HogFunctionType,
+    HogFunctionTypeType,
     PersonType,
     PropertyFilterType,
     PropertyGroupFilter,
@@ -63,39 +66,49 @@ const NEW_FUNCTION_TEMPLATE: HogFunctionTemplateType = {
     status: 'stable',
 }
 
-export function sanitizeConfiguration(data: HogFunctionConfigurationType): HogFunctionConfigurationType {
-    const sanitizedInputs: Record<string, HogFunctionInputType> = {}
-
-    data.inputs_schema?.forEach((input) => {
-        const secret = data.inputs?.[input.key]?.secret
-        let value = data.inputs?.[input.key]?.value
+export const TYPES_WITH_GLOBALS: HogFunctionTypeType[] = ['transformation', 'destination']
 
-        if (secret) {
-            // If set this means we haven't changed the value
-            sanitizedInputs[input.key] = {
-                value: '********', // Don't send the actual value
-                secret: true,
+export function sanitizeConfiguration(data: HogFunctionConfigurationType): HogFunctionConfigurationType {
+    function sanitizeInputs(
+        data: HogFunctionConfigurationType | HogFunctionMappingType
+    ): Record<string, HogFunctionInputType> {
+        const sanitizedInputs: Record<string, HogFunctionInputType> = {}
+        data.inputs_schema?.forEach((input) => {
+            const secret = data.inputs?.[input.key]?.secret
+            let value = data.inputs?.[input.key]?.value
+
+            if (secret) {
+                // If set this means we haven't changed the value
+                sanitizedInputs[input.key] = {
+                    value: '********', // Don't send the actual value
+                    secret: true,
+                }
+                return
             }
-            return
-        }
 
-        if (input.type === 'json' && typeof value === 'string') {
-            try {
-                value = JSON.parse(value)
-            } catch (e) {
-                // Ignore
+            if (input.type === 'json' && typeof value === 'string') {
+                try {
+                    value = JSON.parse(value)
+                } catch (e) {
+                    // Ignore
+                }
             }
-        }
 
-        sanitizedInputs[input.key] = {
-            value: value,
-        }
-    })
+            sanitizedInputs[input.key] = {
+                value: value,
+            }
+        })
+        return sanitizedInputs
+    }
 
     const payload: HogFunctionConfigurationType = {
         ...data,
         filters: data.filters,
-        inputs: sanitizedInputs,
+        mappings: data.mappings?.map((mapping) => ({
+            ...mapping,
+            inputs: sanitizeInputs(mapping),
+        })),
+        inputs: sanitizeInputs(data),
         masking: data.masking?.hash ? data.masking : null,
         icon_url: data.icon_url,
     }
@@ -107,15 +120,32 @@ const templateToConfiguration = (
     template: HogFunctionTemplateType,
     subTemplate?: HogFunctionSubTemplateType | null
 ): HogFunctionConfigurationType => {
-    const inputs: Record<string, HogFunctionInputType> = {}
+    function getInputs(
+        inputs_schema?: HogFunctionInputSchemaType[] | null,
+        subTemplate?: HogFunctionSubTemplateType | null
+    ): Record<string, HogFunctionInputType> {
+        const inputs: Record<string, HogFunctionInputType> = {}
+        inputs_schema?.forEach((schema) => {
+            if (typeof subTemplate?.inputs?.[schema.key] !== 'undefined') {
+                inputs[schema.key] = { value: subTemplate.inputs[schema.key] }
+            } else if (schema.default !== undefined) {
+                inputs[schema.key] = { value: schema.default }
+            }
+        })
+        return inputs
+    }
 
-    template.inputs_schema?.forEach((schema) => {
-        if (typeof subTemplate?.inputs?.[schema.key] !== 'undefined') {
-            inputs[schema.key] = { value: subTemplate.inputs[schema.key] }
-        } else if (schema.default !== undefined) {
-            inputs[schema.key] = { value: schema.default }
-        }
-    })
+    function getMappingInputs(
+        inputs_schema?: HogFunctionInputSchemaType[] | null
+    ): Record<string, HogFunctionInputType> {
+        const inputs: Record<string, HogFunctionInputType> = {}
+        inputs_schema?.forEach((schema) => {
+            if (schema.default !== undefined) {
+                inputs[schema.key] = { value: schema.default }
+            }
+        })
+        return inputs
+    }
 
     return {
         type: template.type ?? 'destination',
@@ -123,9 +153,15 @@ const templateToConfiguration = (
         description: subTemplate?.name ?? template.description,
         inputs_schema: template.inputs_schema,
         filters: subTemplate?.filters ?? template.filters,
+        mappings: (subTemplate?.mappings ?? template.mappings)?.map(
+            (mapping): HogFunctionMappingType => ({
+                ...mapping,
+                inputs: getMappingInputs(mapping.inputs_schema),
+            })
+        ),
         hog: template.hog,
         icon_url: template.icon_url,
-        inputs,
+        inputs: getInputs(template.inputs_schema, subTemplate),
         enabled: template.type !== 'broadcast',
     }
 }
@@ -139,7 +175,6 @@ export function convertToHogFunctionInvocationGlobals(
     return {
         project: {
             id: team?.id ?? 0,
-
             name: team?.name ?? 'Default project',
             url: projectUrl,
         },
@@ -299,7 +334,7 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
             },
             {
                 sparklineQueryChanged: async ({ sparklineQuery }, breakpoint) => {
-                    if (values.type !== 'destination') {
+                    if (values.type !== 'destination' && values.type !== 'site_destination') {
                         return null
                     }
                     if (values.sparkline === null) {
@@ -363,7 +398,7 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
             null as HogFunctionInvocationGlobals | null,
             {
                 loadSampleGlobals: async (_, breakpoint) => {
-                    if (!values.lastEventQuery || values.type !== 'destination') {
+                    if (!values.lastEventQuery) {
                         return values.sampleGlobals
                     }
                     const errorMessage =
@@ -419,14 +454,17 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
             errors: (data) => {
                 return {
                     name: !data.name ? 'Name is required' : undefined,
+                    mappings:
+                        data.type === 'site_destination' && (!data.mappings || data.mappings.length === 0)
+                            ? 'You must add at least one mapping'
+                            : undefined,
                     ...(values.inputFormErrors as any),
                 }
             },
             submit: async (data) => {
-                const payload = sanitizeConfiguration(data)
-
+                const payload: Record<string, any> = sanitizeConfiguration(data)
                 // Only sent on create
-                ;(payload as any).template_id = props.templateId || values.hogFunction?.template?.id
+                payload.template_id = props.templateId || values.hogFunction?.template?.id
 
                 if (!values.hasAddon) {
                     // Remove the source field if the user doesn't have the addon
@@ -434,7 +472,7 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                     delete payload.inputs_schema
                 }
 
-                await asyncActions.upsertHogFunction(payload)
+                await asyncActions.upsertHogFunction(payload as HogFunctionConfigurationType)
             },
         },
     })),
@@ -456,6 +494,10 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                 return template && template.status !== 'free' && !hasAddon
             },
         ],
+        useMapping: [
+            (s) => [s.hogFunction, s.template],
+            (hogFunction, template) => (hogFunction ?? template)?.type === 'site_destination',
+        ],
         defaultFormState: [
             (s) => [s.template, s.hogFunction, s.subTemplate],
             (template, hogFunction, subTemplate): HogFunctionConfigurationType | null => {
@@ -604,8 +646,26 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
             },
         ],
         matchingFilters: [
-            (s) => [s.configuration],
-            (configuration): PropertyGroupFilter => {
+            (s) => [s.configuration, s.useMapping],
+            (configuration, useMapping): PropertyGroupFilter => {
+                // We're using mappings, but none are provided, so match zero events.
+                if (useMapping && !configuration.mappings?.length) {
+                    return {
+                        type: FilterLogicalOperator.And,
+                        values: [
+                            {
+                                type: FilterLogicalOperator.And,
+                                values: [
+                                    {
+                                        type: PropertyFilterType.HogQL,
+                                        key: 'false',
+                                    },
+                                ],
+                            },
+                        ],
+                    }
+                }
+
                 const seriesProperties: PropertyGroupFilterValue = {
                     type: FilterLogicalOperator.Or,
                     values: [],
@@ -614,7 +674,21 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                     type: FilterLogicalOperator.And,
                     values: [seriesProperties],
                 }
-                for (const event of configuration.filters?.events ?? []) {
+                const allPossibleEventFilters = configuration.filters?.events ?? []
+                const allPossibleActionFilters = configuration.filters?.actions ?? []
+
+                if (Array.isArray(configuration.mappings)) {
+                    for (const mapping of configuration.mappings) {
+                        if (mapping.filters?.events) {
+                            allPossibleEventFilters.push(...mapping.filters.events)
+                        }
+                        if (mapping.filters?.actions) {
+                            allPossibleActionFilters.push(...mapping.filters.actions)
+                        }
+                    }
+                }
+
+                for (const event of allPossibleEventFilters) {
                     const eventProperties: AnyPropertyFilter[] = [...(event.properties ?? [])]
                     if (event.id) {
                         eventProperties.push({
@@ -633,7 +707,7 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                         values: eventProperties,
                     })
                 }
-                for (const action of configuration.filters?.actions ?? []) {
+                for (const action of allPossibleActionFilters) {
                     const actionProperties: AnyPropertyFilter[] = [...(action.properties ?? [])]
                     if (action.id) {
                         actionProperties.push({
@@ -664,7 +738,7 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
         sparklineQuery: [
             (s) => [s.configuration, s.matchingFilters, s.type],
             (configuration, matchingFilters, type): TrendsQuery | null => {
-                if (type !== 'destination') {
+                if (type !== 'destination' && type !== 'site_destination') {
                     return null
                 }
                 return {
@@ -728,7 +802,7 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
         lastEventQuery: [
             (s) => [s.configuration, s.matchingFilters, s.groupTypes, s.type],
             (configuration, matchingFilters, groupTypes, type): EventsQuery | null => {
-                if (type !== 'destination') {
+                if (!TYPES_WITH_GLOBALS.includes(type)) {
                     return null
                 }
                 const query: EventsQuery = {
@@ -760,7 +834,6 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                 return hogFunction?.template?.hog && hogFunction.template.hog !== configuration.hog
             },
         ],
-
         subTemplate: [
             (s) => [s.template, s.subTemplateId],
             (template, subTemplateId) => {
@@ -772,8 +845,11 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                 return subTemplate
             },
         ],
-
         forcedSubTemplateId: [() => [router.selectors.searchParams], ({ sub_template }) => !!sub_template],
+        mappingTemplates: [
+            (s) => [s.hogFunction, s.template],
+            (hogFunction, template) => template?.mapping_templates ?? hogFunction?.template?.mapping_templates ?? [],
+        ],
     })),
 
     listeners(({ actions, values, cache }) => ({
@@ -816,6 +892,20 @@ export const hogFunctionConfigurationLogic = kea<hogFunctionConfigurationLogicTy
                 ...(cache.configFromUrl ?? {}),
             }
 
+            if (values.template?.mapping_templates) {
+                config.mappings = [
+                    ...(config.mappings ?? []),
+                    ...values.template.mapping_templates
+                        .filter((t) => t.include_by_default)
+                        .map((template) => ({
+                            ...template,
+                            inputs: template.inputs_schema?.reduce((acc, input) => {
+                                acc[input.key] = { value: input.default }
+                                return acc
+                            }, {} as Record<string, HogFunctionInputType>),
+                        })),
+                ]
+            }
             const paramsFromUrl = cache.paramsFromUrl ?? {}
             const unsavedConfigurationToApply =
                 (values.unsavedConfiguration?.timestamp ?? 0) > Date.now() - UNSAVED_CONFIGURATION_TTL
diff --git a/frontend/src/scenes/pipeline/hogfunctions/hogFunctionTestLogic.tsx b/frontend/src/scenes/pipeline/hogfunctions/hogFunctionTestLogic.tsx
index 9caa8bc369165..7a06989b5b685 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/hogFunctionTestLogic.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/hogFunctionTestLogic.tsx
@@ -69,9 +69,7 @@ export const hogFunctionTestLogic = kea<hogFunctionTestLogicType>([
     }),
     listeners(({ values, actions }) => ({
         loadSampleGlobalsSuccess: () => {
-            if (values.type === 'destination') {
-                actions.setTestInvocationValue('globals', JSON.stringify(values.sampleGlobals, null, 2))
-            }
+            actions.setTestInvocationValue('globals', JSON.stringify(values.sampleGlobals, null, 2))
         },
     })),
     forms(({ props, actions, values }) => ({
diff --git a/frontend/src/scenes/pipeline/hogfunctions/integrations/HogFunctionInputIntegration.tsx b/frontend/src/scenes/pipeline/hogfunctions/integrations/HogFunctionInputIntegration.tsx
index f92b2f9123deb..e73b679afcd40 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/integrations/HogFunctionInputIntegration.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/integrations/HogFunctionInputIntegration.tsx
@@ -16,6 +16,7 @@ export function HogFunctionInputIntegration({ schema, ...props }: HogFunctionInp
         <>
             <IntegrationChoice
                 {...props}
+                schema={schema}
                 integration={schema.integration}
                 redirectUrl={`${window.location.pathname}?integration_target=${schema.key}`}
                 beforeRedirect={() => persistForUnload()}
diff --git a/frontend/src/scenes/pipeline/hogfunctions/integrations/IntegrationChoice.tsx b/frontend/src/scenes/pipeline/hogfunctions/integrations/IntegrationChoice.tsx
index cee61f7c80c88..334c17ee3d859 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/integrations/IntegrationChoice.tsx
+++ b/frontend/src/scenes/pipeline/hogfunctions/integrations/IntegrationChoice.tsx
@@ -7,10 +7,13 @@ import { IntegrationView } from 'lib/integrations/IntegrationView'
 import { capitalizeFirstLetter } from 'lib/utils'
 import { urls } from 'scenes/urls'
 
+import { HogFunctionInputSchemaType } from '~/types'
+
 export type IntegrationConfigureProps = {
     value?: number
     onChange?: (value: number | null) => void
     redirectUrl?: string
+    schema?: HogFunctionInputSchemaType
     integration?: string
     beforeRedirect?: () => void
 }
@@ -18,6 +21,7 @@ export type IntegrationConfigureProps = {
 export function IntegrationChoice({
     onChange,
     value,
+    schema,
     integration,
     redirectUrl,
     beforeRedirect,
@@ -124,5 +128,13 @@ export function IntegrationChoice({
         </LemonMenu>
     )
 
-    return <>{integrationKind ? <IntegrationView integration={integrationKind} suffix={button} /> : button}</>
+    return (
+        <>
+            {integrationKind ? (
+                <IntegrationView schema={schema} integration={integrationKind} suffix={button} />
+            ) : (
+                button
+            )}
+        </>
+    )
 }
diff --git a/frontend/src/scenes/pipeline/hogfunctions/mapping/HogFunctionMapping.tsx b/frontend/src/scenes/pipeline/hogfunctions/mapping/HogFunctionMapping.tsx
new file mode 100644
index 0000000000000..0cd0a86a5e5ae
--- /dev/null
+++ b/frontend/src/scenes/pipeline/hogfunctions/mapping/HogFunctionMapping.tsx
@@ -0,0 +1,195 @@
+import { IconPlus, IconPlusSmall, IconTrash } from '@posthog/icons'
+import { LemonButton, LemonLabel, LemonSelect } from '@posthog/lemon-ui'
+import { useValues } from 'kea'
+import { Group } from 'kea-forms'
+import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
+import { LemonField } from 'lib/lemon-ui/LemonField'
+import { getDefaultEventName } from 'lib/utils/getAppContext'
+import { useState } from 'react'
+import { ActionFilter } from 'scenes/insights/filters/ActionFilter/ActionFilter'
+import { MathAvailability } from 'scenes/insights/filters/ActionFilter/ActionFilterRow/ActionFilterRow'
+
+import { groupsModel } from '~/models/groupsModel'
+import { EntityTypes, FilterType, HogFunctionConfigurationType, HogFunctionMappingType } from '~/types'
+
+import { hogFunctionConfigurationLogic } from '../hogFunctionConfigurationLogic'
+import { HogFunctionInputs } from '../HogFunctionInputs'
+
+export function HogFunctionMapping(): JSX.Element | null {
+    const { groupsTaxonomicTypes } = useValues(groupsModel)
+    const { useMapping, showSource, mappingTemplates } = useValues(hogFunctionConfigurationLogic)
+    const [selectedMappingTemplate, setSelectedMappingTemplate] = useState<string | null>(null)
+
+    if (!useMapping) {
+        return null
+    }
+
+    return (
+        <LemonField name="mappings">
+            {({ value, onChange }) => {
+                const mappings = (value ?? []) as HogFunctionMappingType[]
+                return (
+                    <>
+                        {mappings.map((mapping, index) => (
+                            <div key={index} className="border bg-bg-light rounded p-3 space-y-2">
+                                <div className="flex items-center justify-between w-full gap-2">
+                                    <LemonLabel info="When an event matches these filters, the function is run with the appended inputs.">
+                                        Mapping #{index + 1}
+                                    </LemonLabel>
+                                    <LemonButton
+                                        key="delete"
+                                        icon={<IconTrash />}
+                                        title="Delete graph series"
+                                        data-attr={`delete-prop-filter-${index}`}
+                                        noPadding
+                                        onClick={() => onChange(mappings.filter((_, i) => i !== index))}
+                                    />
+                                </div>
+                                <ActionFilter
+                                    bordered
+                                    filters={(mapping.filters ?? {}) as FilterType}
+                                    setFilters={(f) =>
+                                        onChange(mappings.map((m, i) => (i === index ? { ...m, filters: f } : m)))
+                                    }
+                                    typeKey={`match-group-${index}`}
+                                    mathAvailability={MathAvailability.None}
+                                    hideRename
+                                    hideDuplicate
+                                    showNestedArrow={false}
+                                    actionsTaxonomicGroupTypes={[
+                                        TaxonomicFilterGroupType.Events,
+                                        TaxonomicFilterGroupType.Actions,
+                                    ]}
+                                    propertiesTaxonomicGroupTypes={[
+                                        TaxonomicFilterGroupType.EventProperties,
+                                        TaxonomicFilterGroupType.EventFeatureFlags,
+                                        TaxonomicFilterGroupType.Elements,
+                                        TaxonomicFilterGroupType.PersonProperties,
+                                        TaxonomicFilterGroupType.HogQLExpression,
+                                        ...groupsTaxonomicTypes,
+                                    ]}
+                                    propertyFiltersPopover
+                                    addFilterDefaultOptions={{
+                                        id: '$pageview',
+                                        name: '$pageview',
+                                        type: EntityTypes.EVENTS,
+                                    }}
+                                    buttonCopy="Add event matcher"
+                                />
+                                <Group name={['mappings', index]}>
+                                    <HogFunctionInputs
+                                        configuration={mapping as HogFunctionConfigurationType}
+                                        setConfigurationValue={(key, value) => {
+                                            onChange(mappings.map((m, i) => (i === index ? { ...m, [key]: value } : m)))
+                                        }}
+                                    />
+                                </Group>
+                                {showSource ? (
+                                    <LemonButton
+                                        icon={<IconPlus />}
+                                        size="small"
+                                        type="secondary"
+                                        className="my-4"
+                                        onClick={() => {
+                                            onChange(
+                                                mappings.map((m, i) => {
+                                                    if (i !== index) {
+                                                        return m
+                                                    }
+                                                    const inputs_schema = m.inputs_schema ?? []
+                                                    return {
+                                                        ...m,
+                                                        inputs_schema: [
+                                                            ...inputs_schema,
+                                                            {
+                                                                type: 'string',
+                                                                key: `var_${inputs_schema.length + 1}`,
+                                                                label: '',
+                                                                required: false,
+                                                            },
+                                                        ],
+                                                    }
+                                                })
+                                            )
+                                        }}
+                                    >
+                                        Add input variable
+                                    </LemonButton>
+                                ) : null}
+                            </div>
+                        ))}
+                        <div className="border bg-bg-light rounded p-3 space-y-2">
+                            <LemonLabel>New Mapping</LemonLabel>
+                            <div className="flex gap-2">
+                                {mappingTemplates.length ? (
+                                    <LemonSelect
+                                        placeholder="Select a template"
+                                        value={selectedMappingTemplate}
+                                        onChange={setSelectedMappingTemplate}
+                                        options={mappingTemplates.map((t) => ({
+                                            label: t.name,
+                                            value: t.name,
+                                        }))}
+                                    />
+                                ) : null}
+                                <LemonButton
+                                    type="secondary"
+                                    data-attr="add-action-event-button"
+                                    icon={<IconPlusSmall />}
+                                    disabledReason={
+                                        mappingTemplates.length && !selectedMappingTemplate
+                                            ? 'Select a mapping template'
+                                            : undefined
+                                    }
+                                    onClick={() => {
+                                        if (selectedMappingTemplate) {
+                                            const mappingTemplate = mappingTemplates.find(
+                                                (t) => t.name === selectedMappingTemplate
+                                            )
+                                            if (mappingTemplate) {
+                                                const { name, ...mapping } = mappingTemplate
+                                                const inputs = mapping.inputs_schema
+                                                    ? Object.fromEntries(
+                                                          mapping.inputs_schema
+                                                              .filter((m) => m.default !== undefined)
+                                                              .map((m) => [
+                                                                  m.key,
+                                                                  { value: structuredClone(m.default) },
+                                                              ])
+                                                      )
+                                                    : {}
+                                                onChange([...mappings, { ...mapping, inputs }])
+                                            }
+                                            setSelectedMappingTemplate(null)
+                                            return
+                                        }
+
+                                        const newMapping = {
+                                            inputs_schema: [],
+                                            inputs: {},
+                                            filters: {
+                                                events: [
+                                                    {
+                                                        id: getDefaultEventName(),
+                                                        name: getDefaultEventName(),
+                                                        type: EntityTypes.EVENTS,
+                                                        order: 0,
+                                                        properties: [],
+                                                    },
+                                                ],
+                                                actions: [],
+                                            },
+                                        }
+                                        onChange([...mappings, newMapping])
+                                    }}
+                                >
+                                    Add mapping
+                                </LemonButton>
+                            </div>
+                        </div>
+                    </>
+                )
+            }}
+        </LemonField>
+    )
+}
diff --git a/frontend/src/scenes/pipeline/hogfunctions/urls.ts b/frontend/src/scenes/pipeline/hogfunctions/urls.ts
index a26ce4a331d55..fce68f1b7a82b 100644
--- a/frontend/src/scenes/pipeline/hogfunctions/urls.ts
+++ b/frontend/src/scenes/pipeline/hogfunctions/urls.ts
@@ -26,7 +26,9 @@ export function hogFunctionUrl(type: HogFunctionTypeType | PipelineStage, id?: s
 }
 
 // Supports both hog function types and pipeline stages themselves as input
-export function hogFunctionTypeToPipelineStage(type: string): PipelineStage {
+export function hogFunctionTypeToPipelineStage(
+    type: string
+): PipelineStage.Destination | PipelineStage.Transformation | PipelineStage.SiteApp {
     switch (type) {
         case 'site_destination':
             return PipelineStage.Destination
@@ -38,6 +40,8 @@ export function hogFunctionTypeToPipelineStage(type: string): PipelineStage {
             return PipelineStage.SiteApp
         case 'site-app':
             return PipelineStage.SiteApp
+        case 'transformation':
+            return PipelineStage.Transformation
         default:
             return PipelineStage.Destination
     }
diff --git a/frontend/src/scenes/pipeline/pipelineAccessLogic.tsx b/frontend/src/scenes/pipeline/pipelineAccessLogic.tsx
index 1d8875dbbedfa..41a3af9ee5aae 100644
--- a/frontend/src/scenes/pipeline/pipelineAccessLogic.tsx
+++ b/frontend/src/scenes/pipeline/pipelineAccessLogic.tsx
@@ -5,7 +5,7 @@ import { AvailableFeature } from '~/types'
 
 import { canConfigurePlugins, canGloballyManagePlugins } from './access'
 import type { pipelineAccessLogicType } from './pipelineAccessLogicType'
-import { Destination, NewDestinationItemType, PipelineBackend, SiteApp } from './types'
+import { Destination, NewDestinationItemType, PipelineBackend, SiteApp, Transformation } from './types'
 
 export const pipelineAccessLogic = kea<pipelineAccessLogicType>([
     path(['scenes', 'pipeline', 'pipelineAccessLogic']),
@@ -25,8 +25,10 @@ export const pipelineAccessLogic = kea<pipelineAccessLogicType>([
 
         canEnableDestination: [
             (s) => [s.canEnableNewDestinations],
-            (canEnableNewDestinations): ((destination: Destination | NewDestinationItemType | SiteApp) => boolean) => {
-                return (destination: Destination | NewDestinationItemType | SiteApp) => {
+            (
+                canEnableNewDestinations
+            ): ((destination: Destination | NewDestinationItemType | SiteApp | Transformation) => boolean) => {
+                return (destination: Destination | NewDestinationItemType | SiteApp | Transformation) => {
                     return destination.backend === PipelineBackend.HogFunction
                         ? ('hog_function' in destination
                               ? destination.hog_function.type === 'site_destination' ||
diff --git a/frontend/src/scenes/pipeline/types.ts b/frontend/src/scenes/pipeline/types.ts
index f3f88cdc16f95..3c1c69cf0f318 100644
--- a/frontend/src/scenes/pipeline/types.ts
+++ b/frontend/src/scenes/pipeline/types.ts
@@ -124,23 +124,19 @@ export function convertToPipelineNode<S extends PipelineStage>(
     ? Source
     : never {
     let node: PipelineNode
+
     // check if type is a hog function
     if ('hog' in candidate) {
         node = {
             stage: stage as PipelineStage.Destination,
             backend: PipelineBackend.HogFunction,
             interval: 'realtime',
-            id:
-                candidate.type === 'destination' ||
-                candidate.type === 'site_destination' ||
-                candidate.type === 'site_app'
-                    ? `hog-${candidate.id}`
-                    : candidate.id,
+            id: `hog-${candidate.id}`,
             name: candidate.name,
             description: candidate.description,
             enabled: candidate.enabled,
             created_at: candidate.created_at,
-            updated_at: candidate.created_at,
+            updated_at: candidate.updated_at,
             hog_function: candidate,
         }
     } else if (isPluginConfig(candidate)) {
diff --git a/frontend/src/scenes/project-homepage/WatchNextPanel.tsx b/frontend/src/scenes/project-homepage/WatchNextPanel.tsx
index 1f7917849e867..4b5714bf93545 100644
--- a/frontend/src/scenes/project-homepage/WatchNextPanel.tsx
+++ b/frontend/src/scenes/project-homepage/WatchNextPanel.tsx
@@ -69,7 +69,6 @@ export function RecordingRow({ recording }: RecordingRowProps): JSX.Element {
             onClick={() => {
                 openSessionPlayer({
                     id: recording.id,
-                    matching_events: recording.matching_events,
                 })
                 reportRecordingOpenedFromRecentRecordingList()
             }}
diff --git a/frontend/src/scenes/projectLogic.ts b/frontend/src/scenes/projectLogic.ts
index d2b71d5f5e35e..b9d29ff625136 100644
--- a/frontend/src/scenes/projectLogic.ts
+++ b/frontend/src/scenes/projectLogic.ts
@@ -52,10 +52,10 @@ export const projectLogic = kea<projectLogicType>([
                         throw new Error('Current project has not been loaded yet, so it cannot be updated!')
                     }
 
-                    const patchedProject = (await api.update(
+                    const patchedProject = await api.update<ProjectType>(
                         `api/projects/${values.currentProject.id}`,
                         payload
-                    )) as ProjectType
+                    )
                     breakpoint()
 
                     // We need to reload current org (which lists its projects) in organizationLogic AND in userLogic
diff --git a/frontend/src/scenes/sceneTypes.ts b/frontend/src/scenes/sceneTypes.ts
index bd7ef16feae3c..74cb1e175500d 100644
--- a/frontend/src/scenes/sceneTypes.ts
+++ b/frontend/src/scenes/sceneTypes.ts
@@ -37,6 +37,7 @@ export enum Scene {
     Action = 'Action',
     Experiments = 'Experiments',
     Experiment = 'Experiment',
+    FeatureManagement = 'FeatureManagement',
     FeatureFlags = 'FeatureFlags',
     FeatureFlag = 'FeatureFlag',
     EarlyAccessFeatures = 'EarlyAccessFeatures',
diff --git a/frontend/src/scenes/scenes.ts b/frontend/src/scenes/scenes.ts
index 92b413ca4ba69..3f007fdaf0e6b 100644
--- a/frontend/src/scenes/scenes.ts
+++ b/frontend/src/scenes/scenes.ts
@@ -214,6 +214,11 @@ export const sceneConfigurations: Record<Scene, SceneConfig> = {
         activityScope: ActivityScope.FEATURE_FLAG,
         defaultDocsPath: '/docs/feature-flags/creating-feature-flags',
     },
+    [Scene.FeatureManagement]: {
+        projectBased: true,
+        name: 'Features',
+        defaultDocsPath: '/docs/feature-flags',
+    },
     [Scene.Surveys]: {
         projectBased: true,
         name: 'Surveys',
@@ -571,6 +576,8 @@ export const routes: Record<string, Scene> = {
     [urls.sqlEditor()]: Scene.SQLEditor,
     [urls.featureFlags()]: Scene.FeatureFlags,
     [urls.featureFlag(':id')]: Scene.FeatureFlag,
+    [urls.featureManagement()]: Scene.FeatureManagement,
+    [urls.featureManagement(':id')]: Scene.FeatureManagement,
     [urls.annotations()]: Scene.DataManagement,
     [urls.annotation(':id')]: Scene.DataManagement,
     [urls.projectHomepage()]: Scene.ProjectHomepage,
diff --git a/frontend/src/scenes/session-recordings/SessionRecordings.tsx b/frontend/src/scenes/session-recordings/SessionRecordings.tsx
index db612745ab2a0..d06f0a27c5cbd 100644
--- a/frontend/src/scenes/session-recordings/SessionRecordings.tsx
+++ b/frontend/src/scenes/session-recordings/SessionRecordings.tsx
@@ -10,10 +10,12 @@ import {
 import { PageHeader } from 'lib/components/PageHeader'
 import { upgradeModalLogic } from 'lib/components/UpgradeModal/upgradeModalLogic'
 import { VersionCheckerBanner } from 'lib/components/VersionChecker/VersionCheckerBanner'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { useAsyncHandler } from 'lib/hooks/useAsyncHandler'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
 import { LemonTabs } from 'lib/lemon-ui/LemonTabs'
 import { Spinner } from 'lib/lemon-ui/Spinner/Spinner'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
 import { NotebookSelectButton } from 'scenes/notebooks/NotebookSelectButton/NotebookSelectButton'
 import { SceneExport } from 'scenes/sceneTypes'
@@ -140,7 +142,10 @@ function Warnings(): JSX.Element {
         type: AuthorizedUrlListType.RECORDING_DOMAINS,
     })
     const { suggestions, authorizedUrls } = useValues(theAuthorizedUrlsLogic)
+    const { featureFlags } = useValues(featureFlagLogic)
+
     const mightBeRefusingRecordings = suggestions.length > 0 && authorizedUrls.length > 0
+    const settingLevel = featureFlags[FEATURE_FLAGS.ENVIRONMENTS] ? 'environment' : 'project'
 
     return (
         <>
@@ -156,7 +161,7 @@ function Warnings(): JSX.Element {
                         children: 'Configure',
                     }}
                 >
-                    Session recordings are currently disabled for this project.
+                    Session recordings are currently disabled for this {settingLevel}.
                 </LemonBanner>
             ) : null}
 
diff --git a/frontend/src/scenes/session-recordings/components/OverviewGrid.tsx b/frontend/src/scenes/session-recordings/components/OverviewGrid.tsx
index 2a1ca4749c44a..5dd92344b995d 100644
--- a/frontend/src/scenes/session-recordings/components/OverviewGrid.tsx
+++ b/frontend/src/scenes/session-recordings/components/OverviewGrid.tsx
@@ -1,6 +1,26 @@
 import { Tooltip } from '@posthog/lemon-ui'
+import { ReactNode } from 'react'
 
-export function OverviewGrid({ children }: { children: React.ReactNode }): JSX.Element {
+interface OverviewItemBase {
+    icon?: ReactNode
+    label: string
+    tooltipTitle?: string
+}
+
+type TextOverviewItem = OverviewItemBase & {
+    type: 'text'
+    value: ReactNode
+}
+
+type PropertyOverviewItem = OverviewItemBase & {
+    type: 'property'
+    property: string
+    value?: string | undefined
+}
+
+export type OverviewItem = TextOverviewItem | PropertyOverviewItem
+
+export function OverviewGrid({ children }: { children: ReactNode }): JSX.Element {
     return (
         <div className="@container/og">
             <div className="grid grid-cols-1 place-items-center gap-4 p-2 @xs/og:grid-cols-2 @md/og:grid-cols-3 ">
@@ -14,16 +34,20 @@ export function OverviewGridItem({
     children,
     description,
     label,
+    icon,
 }: {
-    children: React.ReactNode
-    description: React.ReactNode
-    label: React.ReactNode
+    children?: ReactNode
+    description: ReactNode
+    label: ReactNode
+    icon?: ReactNode
 }): JSX.Element {
     return (
         <Tooltip title={description}>
             <div className="flex flex-1 w-full justify-between items-center ">
-                <div className="text-sm">{label}</div>
-                <div className="text-lg font-semibold">{children}</div>
+                <div className="text-sm">
+                    {icon} {label}
+                </div>
+                <div>{children}</div>
             </div>
         </Tooltip>
     )
diff --git a/frontend/src/scenes/session-recordings/components/SimpleTimeLabel.tsx b/frontend/src/scenes/session-recordings/components/SimpleTimeLabel.tsx
index 20c280ae12fd4..60d88a9aa4a91 100644
--- a/frontend/src/scenes/session-recordings/components/SimpleTimeLabel.tsx
+++ b/frontend/src/scenes/session-recordings/components/SimpleTimeLabel.tsx
@@ -1,3 +1,4 @@
+import clsx from 'clsx'
 import { Dayjs, dayjs } from 'lib/dayjs'
 import { shortTimeZone } from 'lib/utils'
 
@@ -9,14 +10,31 @@ function formatStringFor(d: Dayjs): string {
     return 'DD/MM/YYYY HH:mm:ss'
 }
 
-export function SimpleTimeLabel({ startTime, isUTC }: { startTime: string | number; isUTC: boolean }): JSX.Element {
+export function SimpleTimeLabel({
+    startTime,
+    isUTC,
+    muted = true,
+    size = 'xsmall',
+}: {
+    startTime: string | number | Dayjs
+    isUTC: boolean
+    muted?: boolean
+    size?: 'small' | 'xsmall'
+}): JSX.Element {
     let d = dayjs(startTime)
     if (isUTC) {
         d = d.tz('UTC')
     }
 
     return (
-        <div className="overflow-hidden text-ellipsis text-xs text-muted shrink-0">
+        <div
+            className={clsx(
+                'overflow-hidden text-ellipsis shrink-0',
+                muted && 'text-muted',
+                size === 'xsmall' && 'text-xs',
+                size === 'small' && 'text-sm'
+            )}
+        >
             {d.format(formatStringFor(d))} {isUTC ? 'UTC' : shortTimeZone(undefined, dayjs(d).toDate())}
         </div>
     )
diff --git a/frontend/src/scenes/session-recordings/detail/SessionRecordingDetail.tsx b/frontend/src/scenes/session-recordings/detail/SessionRecordingDetail.tsx
index 33bbdfb3e4acb..0c7547badc518 100644
--- a/frontend/src/scenes/session-recordings/detail/SessionRecordingDetail.tsx
+++ b/frontend/src/scenes/session-recordings/detail/SessionRecordingDetail.tsx
@@ -2,8 +2,10 @@ import './SessionRecordingScene.scss'
 
 import { useValues } from 'kea'
 import { PageHeader } from 'lib/components/PageHeader'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
 import { Link } from 'lib/lemon-ui/Link'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { SceneExport } from 'scenes/sceneTypes'
 import {
     sessionRecordingDetailLogic,
@@ -24,14 +26,19 @@ export const scene: SceneExport = {
 
 export function SessionRecordingDetail({ id }: SessionRecordingDetailLogicProps = {}): JSX.Element {
     const { currentTeam } = useValues(teamLogic)
+    const { featureFlags } = useValues(featureFlagLogic)
+
+    const settingLevel = featureFlags[FEATURE_FLAGS.ENVIRONMENTS] ? 'environment' : 'project'
+
     return (
         <div className="SessionRecordingScene">
             <PageHeader />
             {currentTeam && !currentTeam?.session_recording_opt_in ? (
                 <div className="mb-4">
                     <LemonBanner type="info">
-                        Session recordings are currently disabled for this project. To use this feature, please go to
-                        your <Link to={`${urls.settings('project')}#recordings`}>project settings</Link> and enable it.
+                        Session recordings are currently disabled for this {settingLevel}. To use this feature, please
+                        go to your <Link to={`${urls.settings('project')}#recordings`}>project settings</Link> and
+                        enable it.
                     </LemonBanner>
                 </div>
             ) : null}
diff --git a/frontend/src/scenes/session-recordings/player/PlayerUpNext.tsx b/frontend/src/scenes/session-recordings/player/PlayerUpNext.tsx
index b16df4b1722eb..8e79230261cf8 100644
--- a/frontend/src/scenes/session-recordings/player/PlayerUpNext.tsx
+++ b/frontend/src/scenes/session-recordings/player/PlayerUpNext.tsx
@@ -50,9 +50,13 @@ export function PlayerUpNext({ playlistLogic }: PlayerUpNextProps): JSX.Element
         if (endReached && nextSessionRecording?.id) {
             setAnimate(true)
             setPlayNextAnimationInterrupted(false)
-            timeoutRef.current = setTimeout(() => {
-                goToRecording(true)
-            }, 30000) // NOTE: Keep in sync with SCSS
+            timeoutRef.current = setTimeout(
+                () => {
+                    goToRecording(true)
+                },
+                // NOTE: Keep in sync with SCSS
+                3000
+            )
         }
 
         return () => clearTimeout(timeoutRef.current)
diff --git a/frontend/src/scenes/session-recordings/player/controller/PlayerController.tsx b/frontend/src/scenes/session-recordings/player/controller/PlayerController.tsx
index 9306afef52bbd..0498fb9efe05f 100644
--- a/frontend/src/scenes/session-recordings/player/controller/PlayerController.tsx
+++ b/frontend/src/scenes/session-recordings/player/controller/PlayerController.tsx
@@ -4,6 +4,7 @@ import { useActions, useValues } from 'kea'
 import { useKeyboardHotkeys } from 'lib/hooks/useKeyboardHotkeys'
 import { IconFullScreen, IconSync } from 'lib/lemon-ui/icons'
 import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { humanFriendlyDuration } from 'lib/utils'
 import {
     SettingsBar,
     SettingsButton,
@@ -25,13 +26,18 @@ import { SeekSkip, Timestamp } from './PlayerControllerTime'
 import { Seekbar } from './Seekbar'
 
 function SetPlaybackSpeed(): JSX.Element {
-    const { speed } = useValues(sessionRecordingPlayerLogic)
+    const { speed, sessionPlayerData } = useValues(sessionRecordingPlayerLogic)
     const { setSpeed } = useActions(sessionRecordingPlayerLogic)
     return (
         <SettingsMenu
             data-attr="session-recording-speed-select"
             items={PLAYBACK_SPEEDS.map((speedToggle) => ({
-                label: `${speedToggle}x`,
+                label: (
+                    <div className="flex w-full space-x-2 justify-between">
+                        <span>{speedToggle}x</span>
+                        <span>({humanFriendlyDuration(sessionPlayerData.durationMs / speedToggle / 1000)})</span>
+                    </div>
+                ),
                 onClick: () => setSpeed(speedToggle),
                 active: speed === speedToggle && speedToggle !== 1,
                 status: speed === speedToggle ? 'danger' : 'default',
@@ -163,7 +169,11 @@ function FullScreen(): JSX.Element {
         <LemonButton
             size="xsmall"
             onClick={() => setIsFullScreen(!isFullScreen)}
-            tooltip={`${!isFullScreen ? 'Go' : 'Exit'} full screen (F)`}
+            tooltip={
+                <>
+                    {!isFullScreen ? 'Go' : 'Exit'} full screen <KeyboardShortcut f />
+                </>
+            }
         >
             <IconFullScreen className={clsx('text-2xl', isFullScreen ? 'text-link' : 'text-primary-alt')} />
         </LemonButton>
@@ -194,7 +204,11 @@ function Maximise(): JSX.Element {
         <LemonButton
             size="xsmall"
             onClick={onChangeMaximise}
-            tooltip={`${isMaximised ? 'Open' : 'Close'} other panels (M)`}
+            tooltip={
+                <>
+                    {isMaximised ? 'Open' : 'Close'} other panels <KeyboardShortcut m />
+                </>
+            }
             icon={isMaximised ? <IconCollapse45 className="text-lg" /> : <IconExpand45 className="text-lg" />}
         />
     )
diff --git a/frontend/src/scenes/session-recordings/player/controller/PlayerControllerTime.tsx b/frontend/src/scenes/session-recordings/player/controller/PlayerControllerTime.tsx
index 53ac102c92028..417dba1109ce4 100644
--- a/frontend/src/scenes/session-recordings/player/controller/PlayerControllerTime.tsx
+++ b/frontend/src/scenes/session-recordings/player/controller/PlayerControllerTime.tsx
@@ -7,6 +7,9 @@ import { capitalizeFirstLetter, colonDelimitedDuration } from 'lib/utils'
 import { SimpleTimeLabel } from 'scenes/session-recordings/components/SimpleTimeLabel'
 import { ONE_FRAME_MS, sessionRecordingPlayerLogic } from 'scenes/session-recordings/player/sessionRecordingPlayerLogic'
 
+import { KeyboardShortcut } from '~/layout/navigation-3000/components/KeyboardShortcut'
+import { HotKeyOrModifier } from '~/types'
+
 import { playerSettingsLogic, TimestampFormat } from '../playerSettingsLogic'
 import { seekbarLogic } from './seekbarLogic'
 
@@ -44,10 +47,14 @@ export function SeekSkip({ direction }: { direction: 'forward' | 'backward' }):
 
     const altKeyHeld = useKeyHeld('Alt')
     const jumpTimeSeconds = altKeyHeld ? 1 : jumpTimeMs / 1000
-    const altKeyName = navigator.platform.includes('Mac') ? '⌥' : 'Alt'
 
-    const arrowSymbol = direction === 'forward' ? '→' : '←'
-    const arrowName = direction === 'forward' ? 'right' : 'left'
+    const arrowKey: Partial<Record<HotKeyOrModifier, true>> = {}
+    if (direction === 'forward') {
+        arrowKey.arrowright = true
+    }
+    if (direction === 'backward') {
+        arrowKey.arrowleft = true
+    }
 
     return (
         <Tooltip
@@ -56,18 +63,12 @@ export function SeekSkip({ direction }: { direction: 'forward' | 'backward' }):
                 <div className="text-center">
                     {!altKeyHeld ? (
                         <>
-                            {capitalizeFirstLetter(direction)} {jumpTimeSeconds}s (
-                            <kbd>
-                                {arrowSymbol} {arrowName} arrow
-                            </kbd>
-                            ) <br />
+                            {capitalizeFirstLetter(direction)} {jumpTimeSeconds}s <KeyboardShortcut {...arrowKey} />
+                            <br />
                         </>
                     ) : null}
-                    {capitalizeFirstLetter(direction)} 1 frame ({ONE_FRAME_MS}ms) (
-                    <kbd>
-                        {altKeyName} + {arrowSymbol}
-                    </kbd>
-                    )
+                    {capitalizeFirstLetter(direction)} 1 frame ({ONE_FRAME_MS}ms){' '}
+                    <KeyboardShortcut option {...arrowKey} />
                 </div>
             }
         >
diff --git a/frontend/src/scenes/session-recordings/player/inspector/PlayerInspectorBottomSettings.tsx b/frontend/src/scenes/session-recordings/player/inspector/PlayerInspectorBottomSettings.tsx
index d5341305dd2c8..b6287ef3fdb30 100644
--- a/frontend/src/scenes/session-recordings/player/inspector/PlayerInspectorBottomSettings.tsx
+++ b/frontend/src/scenes/session-recordings/player/inspector/PlayerInspectorBottomSettings.tsx
@@ -1,8 +1,9 @@
 import './PlayerInspectorList.scss'
 
+import { BaseIcon, IconCheck } from '@posthog/icons'
 import { useActions, useValues } from 'kea'
 import { userPreferencesLogic } from 'lib/logic/userPreferencesLogic'
-import { SettingsBar, SettingsToggle } from 'scenes/session-recordings/components/PanelSettings'
+import { SettingsBar, SettingsMenu, SettingsToggle } from 'scenes/session-recordings/components/PanelSettings'
 import { miniFiltersLogic } from 'scenes/session-recordings/player/inspector/miniFiltersLogic'
 
 import { FilterableInspectorListItemTypes } from '~/types'
@@ -10,32 +11,39 @@ import { FilterableInspectorListItemTypes } from '~/types'
 import { sessionRecordingPlayerLogic } from '../sessionRecordingPlayerLogic'
 import { playerInspectorLogic } from './playerInspectorLogic'
 
-function HideProperties(): JSX.Element | null {
+function HideProperties(): JSX.Element {
     const { logicProps } = useValues(sessionRecordingPlayerLogic)
     const inspectorLogic = playerInspectorLogic(logicProps)
 
-    const { allItemsByItemType } = useValues(inspectorLogic)
+    const { hasEventsToDisplay } = useValues(inspectorLogic)
+    const { hasEventsFiltersSelected } = useValues(miniFiltersLogic)
+
+    const { hideNullValues } = useValues(userPreferencesLogic)
+    const { setHideNullValues } = useActions(userPreferencesLogic)
 
-    const { miniFiltersForType } = useValues(miniFiltersLogic)
     const { hidePostHogPropertiesInTable } = useValues(userPreferencesLogic)
     const { setHidePostHogPropertiesInTable } = useActions(userPreferencesLogic)
 
-    const hasEventsFiltersSelected = miniFiltersForType(FilterableInspectorListItemTypes.EVENTS).some((x) => x.enabled)
-    const hasEventsToDisplay = allItemsByItemType[FilterableInspectorListItemTypes.EVENTS]?.length > 0
-
     return (
-        <SettingsToggle
-            title={
-                hidePostHogPropertiesInTable
-                    ? 'Do not show PostHog properties in expanded events'
-                    : 'Show PostHog properties in expanded events'
-            }
-            label="Hide PostHog properties"
-            onClick={() => setHidePostHogPropertiesInTable(!hidePostHogPropertiesInTable)}
-            disabledReason={
-                hasEventsToDisplay && hasEventsFiltersSelected ? undefined : 'There are no events in the list'
-            }
-            active={hidePostHogPropertiesInTable}
+        <SettingsMenu
+            items={[
+                {
+                    label: <>{hidePostHogPropertiesInTable ? <IconCheck /> : <BaseIcon />} Hide PostHog properties</>,
+                    onClick: () => setHidePostHogPropertiesInTable(!hidePostHogPropertiesInTable),
+                    active: hidePostHogPropertiesInTable,
+                    disabledReason:
+                        hasEventsToDisplay && hasEventsFiltersSelected ? undefined : 'There are no events in the list',
+                },
+                {
+                    label: <>{hideNullValues ? <IconCheck /> : <BaseIcon />} Hide null values</>,
+                    onClick: () => setHideNullValues(!hideNullValues),
+                    active: hideNullValues,
+                    disabledReason:
+                        hasEventsToDisplay && hasEventsFiltersSelected ? undefined : 'There are no events in the list',
+                },
+            ]}
+            label="Hide properties"
+            highlightWhenActive={false}
         />
     )
 }
diff --git a/frontend/src/scenes/session-recordings/player/inspector/miniFiltersLogic.ts b/frontend/src/scenes/session-recordings/player/inspector/miniFiltersLogic.ts
index 357e0eb4a12f6..27953c893b9cb 100644
--- a/frontend/src/scenes/session-recordings/player/inspector/miniFiltersLogic.ts
+++ b/frontend/src/scenes/session-recordings/player/inspector/miniFiltersLogic.ts
@@ -176,6 +176,11 @@ export const miniFiltersLogic = kea<miniFiltersLogicType>([
             },
         ],
 
+        hasEventsFiltersSelected: [
+            (s) => [s.miniFiltersForType],
+            (miniFiltersForType) => miniFiltersForType(FilterableInspectorListItemTypes.EVENTS).some((x) => x.enabled),
+        ],
+
         miniFilters: [
             (s) => [s.selectedMiniFilters],
             (selectedMiniFilters): SharedListMiniFilter[] => {
diff --git a/frontend/src/scenes/session-recordings/player/inspector/playerInspectorLogic.ts b/frontend/src/scenes/session-recordings/player/inspector/playerInspectorLogic.ts
index f3d380dbc14f7..5fe1914f28852 100644
--- a/frontend/src/scenes/session-recordings/player/inspector/playerInspectorLogic.ts
+++ b/frontend/src/scenes/session-recordings/player/inspector/playerInspectorLogic.ts
@@ -4,7 +4,9 @@ import { actions, connect, events, kea, key, listeners, path, props, propsChange
 import { loaders } from 'kea-loaders'
 import api from 'lib/api'
 import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { Dayjs, dayjs } from 'lib/dayjs'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { getCoreFilterDefinition } from 'lib/taxonomy'
 import { eventToDescription, humanizeBytes, objectsEqual, toParams } from 'lib/utils'
 import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
@@ -22,6 +24,7 @@ import {
     MatchingEventsMatchType,
 } from 'scenes/session-recordings/playlist/sessionRecordingsPlaylistLogic'
 
+import { RecordingsQuery } from '~/queries/schema'
 import {
     FilterableInspectorListItemTypes,
     MatchedRecordingEvent,
@@ -248,6 +251,8 @@ export const playerInspectorLogic = kea<playerInspectorLogicType>([
             ['allPerformanceEvents'],
             sessionRecordingDataLogic(props),
             ['trackedWindow'],
+            featureFlagLogic,
+            ['featureFlags'],
         ],
     })),
     actions(() => ({
@@ -275,7 +280,7 @@ export const playerInspectorLogic = kea<playerInspectorLogicType>([
             },
         ],
     })),
-    loaders(({ props }) => ({
+    loaders(({ props, values }) => ({
         matchingEventUUIDs: [
             [] as MatchedRecordingEvent[] | null,
             {
@@ -297,17 +302,29 @@ export const playerInspectorLogic = kea<playerInspectorLogicType>([
                     if (!filters) {
                         throw new Error('Backend matching events type must include its filters')
                     }
-                    const params = toParams({
+                    // as_query is a temporary parameter as a flag
+                    // to let the backend know not to convert the query to a legacy filter when processing
+                    const params: RecordingsQuery & { as_query?: boolean } = {
                         ...convertUniversalFiltersToRecordingsQuery(filters),
                         session_ids: [props.sessionRecordingId],
-                    })
-                    const response = await api.recordings.getMatchingEvents(params)
+                    }
+                    if (values.listAPIAsQuery) {
+                        params.as_query = true
+                    }
+                    const response = await api.recordings.getMatchingEvents(toParams(params))
                     return response.results.map((x) => ({ uuid: x } as MatchedRecordingEvent))
                 },
             },
         ],
     })),
     selectors(({ props }) => ({
+        listAPIAsQuery: [
+            (s) => [s.featureFlags],
+            (featureFlags) => {
+                return !!featureFlags[FEATURE_FLAGS.REPLAY_LIST_RECORDINGS_AS_QUERY]
+            },
+        ],
+
         allowMatchingEventsFilter: [
             (s) => [s.miniFilters],
             (miniFilters): boolean => {
@@ -984,6 +1001,11 @@ export const playerInspectorLogic = kea<playerInspectorLogicType>([
                 return itemsByType
             },
         ],
+
+        hasEventsToDisplay: [
+            (s) => [s.allItemsByItemType],
+            (allItemsByItemType): boolean => allItemsByItemType[FilterableInspectorListItemTypes.EVENTS]?.length > 0,
+        ],
     })),
     listeners(({ values, actions }) => ({
         setItemExpanded: ({ index, expanded }) => {
diff --git a/frontend/src/scenes/session-recordings/player/playerMetaLogic.ts b/frontend/src/scenes/session-recordings/player/playerMetaLogic.tsx
similarity index 84%
rename from frontend/src/scenes/session-recordings/player/playerMetaLogic.ts
rename to frontend/src/scenes/session-recordings/player/playerMetaLogic.tsx
index 262178b32c008..9d2267922cc2d 100644
--- a/frontend/src/scenes/session-recordings/player/playerMetaLogic.ts
+++ b/frontend/src/scenes/session-recordings/player/playerMetaLogic.tsx
@@ -1,3 +1,4 @@
+import { IconCursorClick, IconKeyboard, IconWarning } from '@posthog/icons'
 import { eventWithTime } from '@rrweb/types'
 import { actions, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
 import { loaders } from 'kea-loaders'
@@ -8,6 +9,7 @@ import { getCoreFilterDefinition } from 'lib/taxonomy'
 import { ceilMsToClosestSecond, findLastIndex, objectsEqual } from 'lib/utils'
 import posthog from 'posthog-js'
 import { countryCodeToName } from 'scenes/insights/views/WorldMap'
+import { OverviewItem } from 'scenes/session-recordings/components/OverviewGrid'
 import { sessionRecordingDataLogic } from 'scenes/session-recordings/player/sessionRecordingDataLogic'
 import {
     sessionRecordingPlayerLogic,
@@ -16,17 +18,10 @@ import {
 
 import { PersonType } from '~/types'
 
+import { SimpleTimeLabel } from '../components/SimpleTimeLabel'
 import { sessionRecordingsListPropertiesLogic } from '../playlist/sessionRecordingsListPropertiesLogic'
 import type { playerMetaLogicType } from './playerMetaLogicType'
 
-export interface OverviewItem {
-    property: string
-    label: string
-    value: string
-    type: 'text' | 'icon'
-    tooltipTitle?: string
-}
-
 const browserPropertyKeys = ['$geoip_country_code', '$browser', '$device_type', '$os']
 const mobilePropertyKeys = ['$geoip_country_code', '$device_type', '$os_name']
 const recordingPropertyKeys = ['click_count', 'keypress_count', 'console_error_count'] as const
@@ -133,6 +128,14 @@ export const playerMetaLogic = kea<playerMetaLogicType>([
                 return sessionPlayerData.start ?? null
             },
         ],
+
+        endTime: [
+            (s) => [s.sessionPlayerData],
+            (sessionPlayerData) => {
+                return sessionPlayerData.end ?? null
+            },
+        ],
+
         currentWindowIndex: [
             (s) => [s.windowIds, s.currentSegment],
             (windowIds, currentSegment) => {
@@ -186,19 +189,39 @@ export const playerMetaLogic = kea<playerMetaLogicType>([
             },
         ],
         overviewItems: [
-            (s) => [s.sessionPlayerMetaData],
-            (sessionPlayerMetaData) => {
+            (s) => [s.sessionPlayerMetaData, s.startTime, s.endTime],
+            (sessionPlayerMetaData, startTime, endTime) => {
                 const items: OverviewItem[] = []
+                if (startTime) {
+                    items.push({
+                        label: 'Session start',
+                        value: <SimpleTimeLabel muted={false} size="small" isUTC={true} startTime={startTime} />,
+                        type: 'text',
+                    })
+                }
+                if (endTime) {
+                    items.push({
+                        label: 'Session end',
+                        value: <SimpleTimeLabel muted={false} size="small" isUTC={true} startTime={endTime} />,
+                        type: 'text',
+                    })
+                }
 
                 recordingPropertyKeys.forEach((property) => {
                     if (sessionPlayerMetaData?.[property]) {
                         items.push({
-                            label: `${sessionPlayerMetaData[property]} ${
-                                getCoreFilterDefinition(property, TaxonomicFilterGroupType.Replay)?.label ?? property
-                            }`,
-                            value: '',
+                            icon:
+                                property === 'click_count' ? (
+                                    <IconCursorClick />
+                                ) : property === 'keypress_count' ? (
+                                    <IconKeyboard />
+                                ) : property === 'console_error_count' ? (
+                                    <IconWarning />
+                                ) : undefined,
+                            label:
+                                getCoreFilterDefinition(property, TaxonomicFilterGroupType.Replay)?.label ?? property,
+                            value: `${sessionPlayerMetaData[property]}`,
                             type: 'text',
-                            property,
                         })
                     }
                 })
@@ -223,7 +246,7 @@ export const playerMetaLogic = kea<playerMetaLogicType>([
                                 property,
                             value,
                             tooltipTitle,
-                            type: 'icon',
+                            type: 'property',
                             property,
                         })
                     }
diff --git a/frontend/src/scenes/session-recordings/player/sessionRecordingPlayerLogic.ts b/frontend/src/scenes/session-recordings/player/sessionRecordingPlayerLogic.ts
index b9b06bfedc101..cfda001ed9ea5 100644
--- a/frontend/src/scenes/session-recordings/player/sessionRecordingPlayerLogic.ts
+++ b/frontend/src/scenes/session-recordings/player/sessionRecordingPlayerLogic.ts
@@ -20,7 +20,7 @@ import { subscriptions } from 'kea-subscriptions'
 import { delay } from 'kea-test-utils'
 import { now } from 'lib/dayjs'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
-import { clamp, downloadFile } from 'lib/utils'
+import { clamp, downloadFile, objectsEqual } from 'lib/utils'
 import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
 import { wrapConsole } from 'lib/utils/wrapConsole'
 import posthog from 'posthog-js'
@@ -521,15 +521,23 @@ export const sessionRecordingPlayerLogic = kea<sessionRecordingPlayerLogicType>(
         ],
         segmentForTimestamp: [
             (s) => [s.sessionPlayerData],
-            (sessionPlayerData) => {
+            (sessionPlayerData: SessionPlayerData) => {
                 return (timestamp?: number): RecordingSegment | null => {
                     if (timestamp === undefined) {
                         return null
                     }
-                    for (const segment of sessionPlayerData.segments) {
-                        if (segment.startTimestamp <= timestamp && segment.endTimestamp >= timestamp) {
-                            return segment
+                    if (sessionPlayerData.segments.length) {
+                        for (const segment of sessionPlayerData.segments) {
+                            if (segment.startTimestamp <= timestamp && timestamp <= segment.endTimestamp) {
+                                return segment
+                            }
                         }
+                        return {
+                            kind: 'buffer',
+                            startTimestamp: timestamp,
+                            endTimestamp: sessionPlayerData.segments[0].startTimestamp - 1,
+                            isActive: false,
+                        } as RecordingSegment
                     }
                     return null
                 }
@@ -852,26 +860,32 @@ export const sessionRecordingPlayerLogic = kea<sessionRecordingPlayerLogicType>(
             // Check if we're seeking to a new segment
             const segment = values.segmentForTimestamp(timestamp)
 
-            if (segment && segment !== values.currentSegment) {
+            if (segment && !objectsEqual(segment, values.currentSegment)) {
                 actions.setCurrentSegment(segment)
             }
 
-            if (!values.snapshotsLoaded) {
-                // We haven't started properly loading, or we're still polling so nothing to do
-            } else if (!values.isRealtimePolling && !values.snapshotsLoading && segment?.kind === 'buffer') {
-                // If not currently loading anything,
-                // and part of the recording hasn't loaded, set error state
-                values.player?.replayer?.pause()
-                actions.endBuffer()
-                console.error("Error: Player tried to seek to a position that hasn't loaded yet")
-                actions.setErrorPlayerState(true)
-            }
-
             // If next time is greater than last buffered time, set to buffering
             else if (segment?.kind === 'buffer') {
-                values.player?.replayer?.pause()
-                actions.startBuffer()
-                actions.setErrorPlayerState(false)
+                const isStillLoading = values.isRealtimePolling || values.snapshotsLoading
+                const isPastEnd = values.sessionPlayerData.end && timestamp > values.sessionPlayerData.end.valueOf()
+                if (isStillLoading) {
+                    values.player?.replayer?.pause()
+                    actions.startBuffer()
+                    actions.setErrorPlayerState(false)
+                } else {
+                    if (isPastEnd) {
+                        actions.setEndReached(true)
+                    } else {
+                        // If not currently loading anything,
+                        // not past the end of the recording,
+                        // and part of the recording hasn't loaded,
+                        // set error state
+                        values.player?.replayer?.pause()
+                        actions.endBuffer()
+                        console.error("Error: Player tried to seek to a position that hasn't loaded yet")
+                        actions.setErrorPlayerState(true)
+                    }
+                }
             }
 
             // If not forced to play and if last playing state was pause, pause
diff --git a/frontend/src/scenes/session-recordings/player/sidebar/PlayerSidebarOverviewGrid.tsx b/frontend/src/scenes/session-recordings/player/sidebar/PlayerSidebarOverviewGrid.tsx
index 161e5acf59f7a..18cc517c3be54 100644
--- a/frontend/src/scenes/session-recordings/player/sidebar/PlayerSidebarOverviewGrid.tsx
+++ b/frontend/src/scenes/session-recordings/player/sidebar/PlayerSidebarOverviewGrid.tsx
@@ -13,8 +13,13 @@ export function PlayerSidebarOverviewGrid(): JSX.Element {
         <div className="rounded border bg-bg-light m-2">
             <OverviewGrid>
                 {overviewItems.map((item) => (
-                    <OverviewGridItem key={item.label} description={item.tooltipTitle} label={item.label}>
-                        {item.type === 'icon' ? (
+                    <OverviewGridItem
+                        key={item.label}
+                        description={item.tooltipTitle}
+                        label={item.label}
+                        icon={item.icon}
+                    >
+                        {item.type === 'property' ? (
                             <PropertyIcon property={item.property} value={item.value} />
                         ) : (
                             item.value
diff --git a/frontend/src/scenes/session-recordings/player/utils/__snapshots__/segmenter.test.ts.snap b/frontend/src/scenes/session-recordings/player/utils/__snapshots__/segmenter.test.ts.snap
index 4ab3c11f932c8..67255fb2782e6 100644
--- a/frontend/src/scenes/session-recordings/player/utils/__snapshots__/segmenter.test.ts.snap
+++ b/frontend/src/scenes/session-recordings/player/utils/__snapshots__/segmenter.test.ts.snap
@@ -2,6 +2,13 @@
 
 exports[`segmenter can segment to include only one window 1`] = `
 [
+  {
+    "durationMs": 10,
+    "endTimestamp": 1672531200010,
+    "isActive": false,
+    "kind": "gap",
+    "startTimestamp": 1672531200000,
+  },
   {
     "durationMs": 0,
     "endTimestamp": 1672531200010,
diff --git a/frontend/src/scenes/session-recordings/player/utils/segmenter.ts b/frontend/src/scenes/session-recordings/player/utils/segmenter.ts
index 456dc1e7ebd43..1df94c89f63ca 100644
--- a/frontend/src/scenes/session-recordings/player/utils/segmenter.ts
+++ b/frontend/src/scenes/session-recordings/player/utils/segmenter.ts
@@ -152,7 +152,7 @@ export const createSegments = (
         const list = [...acc]
 
         if (previousSegment && segment.startTimestamp !== previousSegment.endTimestamp) {
-            // If the segments do not immediately follow each other then we add a "gap" segment
+            // If the segments do not immediately follow each other, then we add a "gap" segment
             const startTimestamp = previousSegment.endTimestamp
             const endTimestamp = segment.startTimestamp
             // Offset the window ID check so we look for a subsequent segment
@@ -186,6 +186,17 @@ export const createSegments = (
                 isActive: false,
             } as RecordingSegment)
         }
+
+        // if the first segment starts after the start of the session, add a gap segment at the beginning
+        const firstTimestamp = segments[0]?.startTimestamp
+        if (firstTimestamp && firstTimestamp > start.valueOf()) {
+            segments.unshift({
+                kind: 'gap',
+                startTimestamp: start.valueOf(),
+                endTimestamp: firstTimestamp,
+                isActive: false,
+            } as RecordingSegment)
+        }
     }
 
     segments = segments.map((segment) => {
diff --git a/frontend/src/scenes/session-recordings/playlist/SessionRecordingPreview.tsx b/frontend/src/scenes/session-recordings/playlist/SessionRecordingPreview.tsx
index 06d87abfc35d7..79d19b833f1c3 100644
--- a/frontend/src/scenes/session-recordings/playlist/SessionRecordingPreview.tsx
+++ b/frontend/src/scenes/session-recordings/playlist/SessionRecordingPreview.tsx
@@ -199,8 +199,8 @@ export function SessionRecordingPreview({
                 )}
                 onClick={() => onClick?.()}
             >
-                <div className="grow overflow-hidden space-y-0.5">
-                    <div className="flex items-center justify-between gap-0.5">
+                <div className="grow overflow-hidden space-y-1">
+                    <div className="flex items-center justify-between space-x-0.5">
                         <div className="flex overflow-hidden font-medium text-link ph-no-capture">
                             <span className="truncate">{asDisplay(recording.person)}</span>
                         </div>
@@ -218,8 +218,8 @@ export function SessionRecordingPreview({
                         )}
                     </div>
 
-                    <div className="flex justify-between items-center gap-0.5">
-                        <div className="flex space-x-2 text-muted text-xs">
+                    <div className="flex justify-between items-center space-x-0.5">
+                        <div className="flex space-x-2 text-muted text-sm">
                             <PropertyIcons
                                 recordingProperties={iconProperties}
                                 iconClassNames={iconClassNames}
@@ -259,7 +259,7 @@ export function SessionRecordingPreview({
 
                 <div
                     className={clsx(
-                        'min-w-6 flex flex-col gap-0.5 items-center',
+                        'min-w-6 flex flex-col space-x-0.5 items-center',
                         // need different margin if the first item is an icon
                         recording.ongoing || pinned ? 'mt-1' : 'mt-2'
                     )}
diff --git a/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx b/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx
index b3cf899123303..023b395b067cc 100644
--- a/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx
+++ b/frontend/src/scenes/session-recordings/playlist/SessionRecordingsPlaylist.tsx
@@ -26,7 +26,10 @@ import {
 } from './SessionRecordingsPlaylistSettings'
 import { SessionRecordingsPlaylistTroubleshooting } from './SessionRecordingsPlaylistTroubleshooting'
 
-export function SessionRecordingsPlaylist(props: SessionRecordingPlaylistLogicProps): JSX.Element {
+export function SessionRecordingsPlaylist({
+    showContent = true,
+    ...props
+}: SessionRecordingPlaylistLogicProps & { showContent?: boolean }): JSX.Element {
     const logicProps: SessionRecordingPlaylistLogicProps = {
         ...props,
         autoPlay: props.autoPlay ?? true,
@@ -122,7 +125,7 @@ export function SessionRecordingsPlaylist(props: SessionRecordingPlaylistLogicPr
                     onSelect={(item) => setSelectedRecordingId(item.id)}
                     activeItemId={activeSessionRecordingId}
                     content={({ activeItem }) =>
-                        activeItem ? (
+                        showContent && activeItem ? (
                             <SessionRecordingPlayer
                                 playerKey={props.logicKey ?? 'playlist'}
                                 sessionRecordingId={activeItem.id}
diff --git a/frontend/src/scenes/settings/Settings.tsx b/frontend/src/scenes/settings/Settings.tsx
index 2c92acb7d59dd..0345733ec2db4 100644
--- a/frontend/src/scenes/settings/Settings.tsx
+++ b/frontend/src/scenes/settings/Settings.tsx
@@ -10,6 +10,7 @@ import { IconChevronRight, IconLink } from 'lib/lemon-ui/icons'
 import { capitalizeFirstLetter, inStorybookTestRunner } from 'lib/utils'
 import React from 'react'
 import { teamLogic } from 'scenes/teamLogic'
+import { urls } from 'scenes/urls'
 
 import { settingsLogic } from './settingsLogic'
 import { SettingsLogicProps } from './types'
@@ -56,7 +57,16 @@ export function Settings({
                                 {levels.map((level) => (
                                     <li key={level} className="space-y-px">
                                         <LemonButton
-                                            onClick={() => selectLevel(level)}
+                                            to={urls.settings(level)}
+                                            onClick={
+                                                // Outside of /settings, we want to select the level without navigating
+                                                props.logicKey === 'settingsScene'
+                                                    ? (e) => {
+                                                          selectLevel(level)
+                                                          e.preventDefault()
+                                                      }
+                                                    : undefined
+                                            }
                                             size="small"
                                             fullWidth
                                             active={selectedLevel === level && !selectedSectionId}
@@ -70,7 +80,16 @@ export function Settings({
                                                 .map((section) => (
                                                     <li key={section.id} className="pl-4">
                                                         <LemonButton
-                                                            onClick={() => selectSection(section.id, section.level)}
+                                                            to={urls.settings(section.id)}
+                                                            onClick={
+                                                                // Outside of /settings, we want to select the level without navigating
+                                                                props.logicKey === 'settingsScene'
+                                                                    ? (e) => {
+                                                                          selectSection(section.id, section.level)
+                                                                          e.preventDefault()
+                                                                      }
+                                                                    : undefined
+                                                            }
                                                             size="small"
                                                             fullWidth
                                                             active={selectedSectionId === section.id}
@@ -116,7 +135,7 @@ export function Settings({
 }
 
 function SettingsRenderer(props: SettingsLogicProps): JSX.Element {
-    const { settings } = useValues(settingsLogic(props))
+    const { settings, selectedLevel, selectedSectionId } = useValues(settingsLogic(props))
     const { selectSetting } = useActions(settingsLogic(props))
 
     return (
@@ -126,7 +145,20 @@ function SettingsRenderer(props: SettingsLogicProps): JSX.Element {
                     <div key={x.id} className="relative">
                         <h2 id={x.id} className="flex gap-2 items-center">
                             {x.title}
-                            <LemonButton icon={<IconLink />} size="small" onClick={() => selectSetting?.(x.id)} />
+                            <LemonButton
+                                icon={<IconLink />}
+                                size="small"
+                                to={urls.settings(selectedSectionId ?? selectedLevel, x.id)}
+                                onClick={
+                                    // Outside of /settings, we want to select the level without navigating
+                                    props.logicKey === 'settingsScene'
+                                        ? (e) => {
+                                              selectSetting(x.id)
+                                              e.preventDefault()
+                                          }
+                                        : undefined
+                                }
+                            />
                         </h2>
                         {x.description && <p>{x.description}</p>}
 
diff --git a/frontend/src/scenes/settings/SettingsMap.tsx b/frontend/src/scenes/settings/SettingsMap.tsx
index 488502b6e164d..8985441f89067 100644
--- a/frontend/src/scenes/settings/SettingsMap.tsx
+++ b/frontend/src/scenes/settings/SettingsMap.tsx
@@ -3,6 +3,7 @@ import { CustomChannelTypes } from 'scenes/settings/environment/CustomChannelTyp
 import { DeadClicksAutocaptureSettings } from 'scenes/settings/environment/DeadClicksAutocaptureSettings'
 import { PersonsJoinMode } from 'scenes/settings/environment/PersonsJoinMode'
 import { PersonsOnEvents } from 'scenes/settings/environment/PersonsOnEvents'
+import { ReplayTriggers } from 'scenes/settings/environment/ReplayTriggers'
 import { SessionsTableVersion } from 'scenes/settings/environment/SessionsTableVersion'
 
 import { Realm } from '~/types'
@@ -59,7 +60,7 @@ import { HedgehogModeSettings } from './user/HedgehogModeSettings'
 import { OptOutCapture } from './user/OptOutCapture'
 import { PersonalAPIKeys } from './user/PersonalAPIKeys'
 import { ThemeSwitcher } from './user/ThemeSwitcher'
-import { TwoFactorAuthentication } from './user/TwoFactorAuthentication'
+import { TwoFactorSettings } from './user/TwoFactorSettings'
 import { UpdateEmailPreferences } from './user/UpdateEmailPreferences'
 import { UserDetails } from './user/UserDetails'
 
@@ -218,7 +219,6 @@ export const SETTINGS_MAP: SettingSection[] = [
                 component: <CustomChannelTypes />,
             },
         ],
-        flag: 'CUSTOM_CHANNEL_TYPE_RULES',
     },
 
     {
@@ -240,6 +240,12 @@ export const SETTINGS_MAP: SettingSection[] = [
                 id: 'replay-authorized-domains',
                 title: 'Authorized domains for replay',
                 component: <ReplayAuthorizedDomains />,
+                allowForTeam: (t) => !!t?.recording_domains?.length,
+            },
+            {
+                id: 'replay-triggers',
+                title: 'Replay triggers',
+                component: <ReplayTriggers />,
             },
             {
                 id: 'replay-ingestion',
@@ -473,7 +479,7 @@ export const SETTINGS_MAP: SettingSection[] = [
             {
                 id: '2fa',
                 title: 'Two-factor authentication',
-                component: <TwoFactorAuthentication />,
+                component: <TwoFactorSettings />,
             },
         ],
     },
diff --git a/frontend/src/scenes/settings/SettingsScene.stories.tsx b/frontend/src/scenes/settings/SettingsScene.stories.tsx
index 8ebdd09f15b14..6584b2a93d717 100644
--- a/frontend/src/scenes/settings/SettingsScene.stories.tsx
+++ b/frontend/src/scenes/settings/SettingsScene.stories.tsx
@@ -46,7 +46,7 @@ export const SettingsProject: StoryFn = () => {
     return <App />
 }
 SettingsProject.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsProjectWithReplayFeatures: StoryFn = () => {
@@ -61,7 +61,7 @@ export const SettingsProjectWithReplayFeatures: StoryFn = () => {
     return <App />
 }
 SettingsProjectWithReplayFeatures.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsUser: StoryFn = () => {
@@ -71,7 +71,7 @@ export const SettingsUser: StoryFn = () => {
     return <App />
 }
 SettingsUser.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsOrganization: StoryFn = () => {
@@ -81,7 +81,7 @@ export const SettingsOrganization: StoryFn = () => {
     return <App />
 }
 SettingsOrganization.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsWebVitals: StoryFn = () => {
@@ -91,7 +91,7 @@ export const SettingsWebVitals: StoryFn = () => {
     return <App />
 }
 SettingsOrganization.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 function TimeSensitiveSettings(props: {
@@ -133,40 +133,40 @@ export const SettingsSessionTimeoutAllOptions: StoryFn = () => {
     return <TimeSensitiveSettings has_password saml_available />
 }
 SettingsSessionTimeoutAllOptions.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsSessionTimeoutPasswordOnly: StoryFn = () => {
     return <TimeSensitiveSettings has_password />
 }
 SettingsSessionTimeoutPasswordOnly.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsSessionTimeoutSsoOnly: StoryFn = () => {
     return <TimeSensitiveSettings />
 }
 SettingsSessionTimeoutSsoOnly.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsSessionTimeoutSsoEnforcedGithub: StoryFn = () => {
     return <TimeSensitiveSettings sso_enforcement="github" />
 }
 SettingsSessionTimeoutSsoEnforcedGithub.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsSessionTimeoutSsoEnforcedGoogle: StoryFn = () => {
     return <TimeSensitiveSettings sso_enforcement="google-oauth2" />
 }
 SettingsSessionTimeoutSsoEnforcedGoogle.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
 
 export const SettingsSessionTimeoutSsoEnforcedSaml: StoryFn = () => {
     return <TimeSensitiveSettings sso_enforcement="saml" />
 }
 SettingsSessionTimeoutSsoEnforcedSaml.parameters = {
-    testOptions: { waitForSelector: '.Settings__sections button' },
+    testOptions: { waitForSelector: '.Settings__sections a' },
 }
diff --git a/frontend/src/scenes/settings/environment/ReplayTriggers.tsx b/frontend/src/scenes/settings/environment/ReplayTriggers.tsx
new file mode 100644
index 0000000000000..48e79bea18cec
--- /dev/null
+++ b/frontend/src/scenes/settings/environment/ReplayTriggers.tsx
@@ -0,0 +1,262 @@
+import { IconPencil, IconPlus, IconTrash } from '@posthog/icons'
+import clsx from 'clsx'
+import { useActions, useValues } from 'kea'
+import { Form } from 'kea-forms'
+import { EventSelect } from 'lib/components/EventSelect/EventSelect'
+import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { LemonDialog } from 'lib/lemon-ui/LemonDialog'
+import { LemonField } from 'lib/lemon-ui/LemonField'
+import { LemonInput } from 'lib/lemon-ui/LemonInput'
+import { LemonLabel } from 'lib/lemon-ui/LemonLabel'
+import { replayTriggersLogic } from 'scenes/settings/environment/replayTriggersLogic'
+import { SupportedPlatforms } from 'scenes/settings/environment/SessionRecordingSettings'
+
+import { SessionReplayUrlTriggerConfig } from '~/types'
+
+function UrlConfigForm({
+    type,
+    onCancel,
+    isSubmitting,
+}: {
+    type: 'trigger' | 'blocklist'
+    onCancel: () => void
+    isSubmitting: boolean
+}): JSX.Element {
+    return (
+        <Form
+            logic={replayTriggersLogic}
+            formKey={type === 'trigger' ? 'proposedUrlTrigger' : 'proposedUrlBlocklist'}
+            enableFormOnSubmit
+            className="w-full flex flex-col border rounded items-center p-2 pl-4 bg-bg-light gap-2"
+        >
+            <div className="flex flex-col gap-2 w-full">
+                <LemonBanner type="info" className="text-sm">
+                    We always wrap the URL regex with anchors to avoid unexpected behavior (if you do not). This is
+                    because <pre className="inline">https://example.com/</pre> does not only match the homepage. You'd
+                    need <pre className="inline">^https://example.com/$</pre>
+                </LemonBanner>
+                <LemonLabel className="w-full">
+                    Matching regex:
+                    <LemonField name="url" className="flex-1">
+                        <LemonInput autoFocus placeholder="Enter URL regex." data-attr="url-input" />
+                    </LemonField>
+                </LemonLabel>
+            </div>
+            <div className="flex justify-end gap-2 w-full">
+                <LemonButton type="secondary" onClick={onCancel}>
+                    Cancel
+                </LemonButton>
+                <LemonButton
+                    htmlType="submit"
+                    type="primary"
+                    disabledReason={isSubmitting ? `Saving url in progress` : undefined}
+                    data-attr="url-save"
+                >
+                    Save
+                </LemonButton>
+            </div>
+        </Form>
+    )
+}
+
+function UrlConfigRow({
+    trigger,
+    index,
+    type,
+    editIndex,
+    onEdit,
+    onRemove,
+}: {
+    trigger: SessionReplayUrlTriggerConfig
+    index: number
+    type: 'trigger' | 'blocklist'
+    editIndex: number | null
+    onEdit: (index: number) => void
+    onRemove: (index: number) => void
+}): JSX.Element {
+    if (editIndex === index) {
+        return (
+            <div className="border rounded p-2 bg-bg-light">
+                <UrlConfigForm type={type} onCancel={() => onEdit(-1)} isSubmitting={false} />
+            </div>
+        )
+    }
+
+    return (
+        <div className={clsx('border rounded flex items-center p-2 pl-4 bg-bg-light')}>
+            <span title={trigger.url} className="flex-1 truncate">
+                {trigger.matching === 'regex' ? 'Matches regex: ' : ''} {trigger.url}
+            </span>
+            <div className="Actions flex space-x-1 shrink-0">
+                <LemonButton icon={<IconPencil />} onClick={() => onEdit(index)} tooltip="Edit" center />
+                <LemonButton
+                    icon={<IconTrash />}
+                    tooltip={`Remove URL ${type}`}
+                    center
+                    onClick={() => {
+                        LemonDialog.open({
+                            title: <>Remove URL {type}</>,
+                            description: `Are you sure you want to remove this URL ${type}?`,
+                            primaryButton: {
+                                status: 'danger',
+                                children: 'Remove',
+                                onClick: () => onRemove(index),
+                            },
+                            secondaryButton: {
+                                children: 'Cancel',
+                            },
+                        })
+                    }}
+                />
+            </div>
+        </div>
+    )
+}
+
+function UrlConfigSection({
+    type,
+    title,
+    description,
+    ...props
+}: {
+    type: 'trigger' | 'blocklist'
+    title: string
+    description: string
+    isAddFormVisible: boolean
+    config: SessionReplayUrlTriggerConfig[] | null
+    editIndex: number | null
+    isSubmitting: boolean
+    onAdd: () => void
+    onCancel: () => void
+    onEdit: (index: number) => void
+    onRemove: (index: number) => void
+}): JSX.Element {
+    return (
+        <div className="flex flex-col space-y-2 mt-4">
+            <div className="flex items-center gap-2 justify-between">
+                <LemonLabel className="text-base">{title}</LemonLabel>
+                <LemonButton
+                    onClick={props.onAdd}
+                    type="secondary"
+                    icon={<IconPlus />}
+                    data-attr={`session-replay-add-url-${type}`}
+                >
+                    Add
+                </LemonButton>
+            </div>
+            <p>{description}</p>
+
+            {props.isAddFormVisible && (
+                <UrlConfigForm type={type} onCancel={props.onCancel} isSubmitting={props.isSubmitting} />
+            )}
+            {props.config?.map((trigger, index) => (
+                <UrlConfigRow
+                    key={`${trigger.url}-${trigger.matching}`}
+                    trigger={trigger}
+                    index={index}
+                    type={type}
+                    editIndex={props.editIndex}
+                    onEdit={props.onEdit}
+                    onRemove={props.onRemove}
+                />
+            ))}
+        </div>
+    )
+}
+
+function UrlTriggerOptions(): JSX.Element | null {
+    const { isAddUrlTriggerConfigFormVisible, urlTriggerConfig, editUrlTriggerIndex, isProposedUrlTriggerSubmitting } =
+        useValues(replayTriggersLogic)
+    const { newUrlTrigger, removeUrlTrigger, setEditUrlTriggerIndex, cancelProposingUrlTrigger } =
+        useActions(replayTriggersLogic)
+
+    return (
+        <UrlConfigSection
+            type="trigger"
+            title="Enable recordings when URL matches"
+            description="Adding a URL trigger means recording will only be started when the user visits a page that matches the URL."
+            isAddFormVisible={isAddUrlTriggerConfigFormVisible}
+            config={urlTriggerConfig}
+            editIndex={editUrlTriggerIndex}
+            isSubmitting={isProposedUrlTriggerSubmitting}
+            onAdd={newUrlTrigger}
+            onCancel={cancelProposingUrlTrigger}
+            onEdit={setEditUrlTriggerIndex}
+            onRemove={removeUrlTrigger}
+        />
+    )
+}
+
+function UrlBlocklistOptions(): JSX.Element | null {
+    const {
+        isAddUrlBlocklistConfigFormVisible,
+        urlBlocklistConfig,
+        editUrlBlocklistIndex,
+        isProposedUrlBlocklistSubmitting,
+    } = useValues(replayTriggersLogic)
+    const { newUrlBlocklist, removeUrlBlocklist, setEditUrlBlocklistIndex, cancelProposingUrlBlocklist } =
+        useActions(replayTriggersLogic)
+
+    return (
+        <UrlConfigSection
+            type="blocklist"
+            title="Block recordings when URL matches"
+            description="Adding a URL blocklist means recording will be paused when the user visits a page that matches the URL."
+            isAddFormVisible={isAddUrlBlocklistConfigFormVisible}
+            config={urlBlocklistConfig}
+            editIndex={editUrlBlocklistIndex}
+            isSubmitting={isProposedUrlBlocklistSubmitting}
+            onAdd={newUrlBlocklist}
+            onCancel={cancelProposingUrlBlocklist}
+            onEdit={setEditUrlBlocklistIndex}
+            onRemove={removeUrlBlocklist}
+        />
+    )
+}
+
+function EventTriggerOptions(): JSX.Element | null {
+    const { eventTriggerConfig } = useValues(replayTriggersLogic)
+    const { updateEventTriggerConfig } = useActions(replayTriggersLogic)
+
+    return (
+        <div className="flex flex-col space-y-2 mt-4">
+            <div className="flex items-center gap-2 justify-between">
+                <LemonLabel className="text-base">Event emitted</LemonLabel>
+            </div>
+            <p>
+                Session recording will be started immediately before PostHog queues any of these events to be sent to
+                the backend.
+            </p>
+
+            <EventSelect
+                filterGroupTypes={[TaxonomicFilterGroupType.Events]}
+                onChange={(includedEvents) => {
+                    updateEventTriggerConfig(includedEvents)
+                }}
+                selectedEvents={eventTriggerConfig ?? []}
+                addElement={
+                    <LemonButton size="small" type="secondary" icon={<IconPlus />} sideIcon={null}>
+                        Add event
+                    </LemonButton>
+                }
+            />
+        </div>
+    )
+}
+
+export function ReplayTriggers(): JSX.Element {
+    return (
+        <div className="space-y-2">
+            <SupportedPlatforms android={false} ios={false} flutter={false} web={true} reactNative={false} />
+            <p>
+                Use the settings below to control when recordings are started or paused. If no triggers are selected,
+                then recordings will always start if enabled.
+            </p>
+            <UrlTriggerOptions />
+            <UrlBlocklistOptions />
+            <EventTriggerOptions />
+        </div>
+    )
+}
diff --git a/frontend/src/scenes/settings/environment/SessionRecordingIngestionSettings.tsx b/frontend/src/scenes/settings/environment/SessionRecordingIngestionSettings.tsx
index bd4a79e41c4ec..69258301575c2 100644
--- a/frontend/src/scenes/settings/environment/SessionRecordingIngestionSettings.tsx
+++ b/frontend/src/scenes/settings/environment/SessionRecordingIngestionSettings.tsx
@@ -1,31 +1,23 @@
-import { IconPencil, IconPlus, IconTrash } from '@posthog/icons'
 import {
     LemonButton,
-    LemonDialog,
-    LemonInput,
     LemonSegmentedButton,
     LemonSegmentedButtonOption,
     LemonSelect,
     Link,
     Spinner,
 } from '@posthog/lemon-ui'
-import clsx from 'clsx'
 import { useActions, useValues } from 'kea'
-import { Form } from 'kea-forms'
-import { EventSelect } from 'lib/components/EventSelect/EventSelect'
-import { FlaggedFeature } from 'lib/components/FlaggedFeature'
 import { FlagSelector } from 'lib/components/FlagSelector'
 import { PayGateMini } from 'lib/components/PayGateMini/PayGateMini'
-import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
-import { FEATURE_FLAGS, SESSION_REPLAY_MINIMUM_DURATION_OPTIONS } from 'lib/constants'
+import { SESSION_REPLAY_MINIMUM_DURATION_OPTIONS } from 'lib/constants'
 import { IconCancel } from 'lib/lemon-ui/icons'
-import { LemonField } from 'lib/lemon-ui/LemonField'
 import { LemonLabel } from 'lib/lemon-ui/LemonLabel/LemonLabel'
+import { SupportedPlatforms } from 'scenes/settings/environment/SessionRecordingSettings'
 import { sessionReplayIngestionControlLogic } from 'scenes/settings/environment/sessionReplayIngestionControlLogic'
 import { teamLogic } from 'scenes/teamLogic'
 import { userLogic } from 'scenes/userLogic'
 
-import { AvailableFeature, MultivariateFlagOptions, SessionReplayUrlTriggerConfig } from '~/types'
+import { AvailableFeature, MultivariateFlagOptions } from '~/types'
 
 function variantOptions(multivariate: MultivariateFlagOptions | undefined): LemonSegmentedButtonOption<string>[] {
     if (!multivariate) {
@@ -123,237 +115,6 @@ function LinkedFlagSelector(): JSX.Element | null {
     )
 }
 
-function UrlConfigForm({
-    type,
-    onCancel,
-    isSubmitting,
-}: {
-    type: 'trigger' | 'blocklist'
-    onCancel: () => void
-    isSubmitting: boolean
-}): JSX.Element {
-    return (
-        <Form
-            logic={sessionReplayIngestionControlLogic}
-            formKey={type === 'trigger' ? 'proposedUrlTrigger' : 'proposedUrlBlocklist'}
-            enableFormOnSubmit
-            className="w-full flex flex-col border rounded items-center p-2 pl-4 bg-bg-light gap-2"
-        >
-            <div className="flex flex-row gap-2 w-full">
-                <LemonField name="matching">
-                    <LemonSelect options={[{ label: 'Regex', value: 'regex' }]} />
-                </LemonField>
-                <LemonField name="url" className="flex-1">
-                    <LemonInput autoFocus placeholder="Enter URL" data-attr="url-input" />
-                </LemonField>
-            </div>
-            <div className="flex justify-end gap-2 w-full">
-                <LemonButton type="secondary" onClick={onCancel}>
-                    Cancel
-                </LemonButton>
-                <LemonButton
-                    htmlType="submit"
-                    type="primary"
-                    disabledReason={isSubmitting ? `Saving url in progress` : undefined}
-                    data-attr="url-save"
-                >
-                    Save
-                </LemonButton>
-            </div>
-        </Form>
-    )
-}
-
-// New shared row component
-function UrlConfigRow({
-    trigger,
-    index,
-    type,
-    editIndex,
-    onEdit,
-    onRemove,
-}: {
-    trigger: SessionReplayUrlTriggerConfig
-    index: number
-    type: 'trigger' | 'blocklist'
-    editIndex: number | null
-    onEdit: (index: number) => void
-    onRemove: (index: number) => void
-}): JSX.Element {
-    if (editIndex === index) {
-        return (
-            <div className="border rounded p-2 bg-bg-light">
-                <UrlConfigForm type={type} onCancel={() => onEdit(-1)} isSubmitting={false} />
-            </div>
-        )
-    }
-
-    return (
-        <div className={clsx('border rounded flex items-center p-2 pl-4 bg-bg-light')}>
-            <span title={trigger.url} className="flex-1 truncate">
-                {trigger.matching === 'regex' ? 'Matches regex: ' : ''} {trigger.url}
-            </span>
-            <div className="Actions flex space-x-1 shrink-0">
-                <LemonButton icon={<IconPencil />} onClick={() => onEdit(index)} tooltip="Edit" center />
-                <LemonButton
-                    icon={<IconTrash />}
-                    tooltip={`Remove URL ${type}`}
-                    center
-                    onClick={() => {
-                        LemonDialog.open({
-                            title: <>Remove URL {type}</>,
-                            description: `Are you sure you want to remove this URL ${type}?`,
-                            primaryButton: {
-                                status: 'danger',
-                                children: 'Remove',
-                                onClick: () => onRemove(index),
-                            },
-                            secondaryButton: {
-                                children: 'Cancel',
-                            },
-                        })
-                    }}
-                />
-            </div>
-        </div>
-    )
-}
-
-function UrlConfigSection({
-    type,
-    title,
-    description,
-    ...props
-}: {
-    type: 'trigger' | 'blocklist'
-    title: string
-    description: string
-    isAddFormVisible: boolean
-    config: SessionReplayUrlTriggerConfig[] | null
-    editIndex: number | null
-    isSubmitting: boolean
-    onAdd: () => void
-    onCancel: () => void
-    onEdit: (index: number) => void
-    onRemove: (index: number) => void
-}): JSX.Element {
-    return (
-        <div className="flex flex-col space-y-2 mt-4">
-            <div className="flex items-center gap-2 justify-between">
-                <LemonLabel className="text-base">{title}</LemonLabel>
-                <LemonButton
-                    onClick={props.onAdd}
-                    type="secondary"
-                    icon={<IconPlus />}
-                    data-attr={`session-replay-add-url-${type}`}
-                >
-                    Add
-                </LemonButton>
-            </div>
-            <p>{description}</p>
-
-            <p>{title} is only available for JavaScript Web.</p>
-
-            {props.isAddFormVisible && (
-                <UrlConfigForm type={type} onCancel={props.onCancel} isSubmitting={props.isSubmitting} />
-            )}
-            {props.config?.map((trigger, index) => (
-                <UrlConfigRow
-                    key={`${trigger.url}-${trigger.matching}`}
-                    trigger={trigger}
-                    index={index}
-                    type={type}
-                    editIndex={props.editIndex}
-                    onEdit={props.onEdit}
-                    onRemove={props.onRemove}
-                />
-            ))}
-        </div>
-    )
-}
-
-function UrlTriggerOptions(): JSX.Element | null {
-    const { isAddUrlTriggerConfigFormVisible, urlTriggerConfig, editUrlTriggerIndex, isProposedUrlTriggerSubmitting } =
-        useValues(sessionReplayIngestionControlLogic)
-    const { newUrlTrigger, removeUrlTrigger, setEditUrlTriggerIndex, cancelProposingUrlTrigger } = useActions(
-        sessionReplayIngestionControlLogic
-    )
-
-    return (
-        <UrlConfigSection
-            type="trigger"
-            title="Enable recordings when URL matches"
-            description="Adding a URL trigger means recording will only be started when the user visits a page that matches the URL."
-            isAddFormVisible={isAddUrlTriggerConfigFormVisible}
-            config={urlTriggerConfig}
-            editIndex={editUrlTriggerIndex}
-            isSubmitting={isProposedUrlTriggerSubmitting}
-            onAdd={newUrlTrigger}
-            onCancel={cancelProposingUrlTrigger}
-            onEdit={setEditUrlTriggerIndex}
-            onRemove={removeUrlTrigger}
-        />
-    )
-}
-
-function UrlBlocklistOptions(): JSX.Element | null {
-    const {
-        isAddUrlBlocklistConfigFormVisible,
-        urlBlocklistConfig,
-        editUrlBlocklistIndex,
-        isProposedUrlBlocklistSubmitting,
-    } = useValues(sessionReplayIngestionControlLogic)
-    const { newUrlBlocklist, removeUrlBlocklist, setEditUrlBlocklistIndex, cancelProposingUrlBlocklist } = useActions(
-        sessionReplayIngestionControlLogic
-    )
-
-    return (
-        <UrlConfigSection
-            type="blocklist"
-            title="Block recordings when URL matches"
-            description="Adding a URL blocklist means recording will be paused when the user visits a page that matches the URL."
-            isAddFormVisible={isAddUrlBlocklistConfigFormVisible}
-            config={urlBlocklistConfig}
-            editIndex={editUrlBlocklistIndex}
-            isSubmitting={isProposedUrlBlocklistSubmitting}
-            onAdd={newUrlBlocklist}
-            onCancel={cancelProposingUrlBlocklist}
-            onEdit={setEditUrlBlocklistIndex}
-            onRemove={removeUrlBlocklist}
-        />
-    )
-}
-
-function EventTriggerOptions(): JSX.Element | null {
-    const { eventTriggerConfig } = useValues(sessionReplayIngestionControlLogic)
-    const { updateEventTriggerConfig } = useActions(sessionReplayIngestionControlLogic)
-
-    return (
-        <div className="flex flex-col space-y-2 mt-4">
-            <div className="flex items-center gap-2 justify-between">
-                <LemonLabel className="text-base">Event emitted</LemonLabel>
-            </div>
-            <p>
-                Session recording will be started immediately before PostHog queues any of these events to be sent to
-                the backend.
-            </p>
-            <p>Event emitted is only available for JavaScript Web.</p>
-            <EventSelect
-                filterGroupTypes={[TaxonomicFilterGroupType.Events]}
-                onChange={(includedEvents) => {
-                    updateEventTriggerConfig(includedEvents)
-                }}
-                selectedEvents={eventTriggerConfig ?? []}
-                addElement={
-                    <LemonButton size="small" type="secondary" icon={<IconPlus />} sideIcon={null}>
-                        Add event
-                    </LemonButton>
-                }
-            />
-        </div>
-    )
-}
-
 export function SessionRecordingIngestionSettings(): JSX.Element | null {
     const { updateCurrentTeam } = useActions(teamLogic)
     const { currentTeam } = useValues(teamLogic)
@@ -378,6 +139,8 @@ export function SessionRecordingIngestionSettings(): JSX.Element | null {
                     </Link>
                 </p>
 
+                <SupportedPlatforms web={true} />
+
                 {samplingControlFeatureEnabled && (
                     <>
                         <div className="flex flex-row justify-between">
@@ -510,11 +273,6 @@ export function SessionRecordingIngestionSettings(): JSX.Element | null {
                     </>
                 )}
                 <LinkedFlagSelector />
-                <UrlTriggerOptions />
-                <FlaggedFeature flag={FEATURE_FLAGS.SESSION_REPLAY_URL_BLOCKLIST}>
-                    <UrlBlocklistOptions />
-                    <EventTriggerOptions />
-                </FlaggedFeature>
             </>
         </PayGateMini>
     )
diff --git a/frontend/src/scenes/settings/environment/SessionRecordingSettings.tsx b/frontend/src/scenes/settings/environment/SessionRecordingSettings.tsx
index ecc30da766820..ff6650d2bffd5 100644
--- a/frontend/src/scenes/settings/environment/SessionRecordingSettings.tsx
+++ b/frontend/src/scenes/settings/environment/SessionRecordingSettings.tsx
@@ -1,5 +1,15 @@
-import { IconPlus } from '@posthog/icons'
-import { LemonBanner, LemonButton, LemonDialog, LemonSwitch, LemonTag, Link } from '@posthog/lemon-ui'
+import { IconCheck, IconInfo, IconPlus, IconX } from '@posthog/icons'
+import {
+    LemonBanner,
+    LemonButton,
+    LemonDialog,
+    LemonDivider,
+    LemonSwitch,
+    LemonTag,
+    Link,
+    Tooltip,
+} from '@posthog/lemon-ui'
+import clsx from 'clsx'
 import { useActions, useValues } from 'kea'
 import { AuthorizedUrlList } from 'lib/components/AuthorizedUrlList/AuthorizedUrlList'
 import { AuthorizedUrlListType } from 'lib/components/AuthorizedUrlList/authorizedUrlListLogic'
@@ -8,11 +18,84 @@ import { PropertySelect } from 'lib/components/PropertySelect/PropertySelect'
 import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
 import { IconSelectEvents } from 'lib/lemon-ui/icons'
 import { LemonLabel } from 'lib/lemon-ui/LemonLabel/LemonLabel'
-import { objectsEqual } from 'lib/utils'
+import { isObject, objectsEqual } from 'lib/utils'
+import { ReactNode } from 'react'
 import { teamLogic } from 'scenes/teamLogic'
 
 import { SessionRecordingAIConfig } from '~/types'
 
+interface SupportedPlatformProps {
+    note?: ReactNode
+    label: string
+    supported: boolean
+}
+
+function SupportedPlatform(props: SupportedPlatformProps): JSX.Element {
+    const node = (
+        <div
+            className={clsx(
+                props.supported ? 'bg-success-highlight' : 'bg-danger-highlight',
+                'px-1 py-0.5',
+                props.note && 'cursor-pointer'
+            )}
+        >
+            {props.note ? <IconInfo /> : props.supported ? <IconCheck /> : <IconX />} {props.label}
+        </div>
+    )
+    if (props.note) {
+        return <Tooltip title={props.note}>{node}</Tooltip>
+    }
+    return node
+}
+
+export function SupportedPlatforms(props: {
+    web?: boolean | { note?: ReactNode }
+    android?: boolean | { note?: ReactNode }
+    ios?: boolean | { note?: ReactNode }
+    reactNative?: boolean | { note?: ReactNode }
+    flutter?: boolean | { note?: ReactNode }
+}): JSX.Element {
+    return (
+        <div className="text-xs inline-flex flex-row bg-bg-3000 rounded items-center border overflow-hidden mb-2">
+            <span className="px-1 py-0.5 font-semibold">Supported platforms:</span>
+            <LemonDivider vertical className="h-full" />
+            <SupportedPlatform
+                note={isObject(props.web) ? props.web.note : undefined}
+                label="Web"
+                supported={!!props.web}
+            />
+
+            <LemonDivider vertical className="h-full" />
+            <SupportedPlatform
+                note={isObject(props.android) ? props.android.note : undefined}
+                label="Android"
+                supported={!!props.android}
+            />
+
+            <LemonDivider vertical className="h-full" />
+            <SupportedPlatform
+                note={isObject(props.ios) ? props.ios.note : undefined}
+                label="iOS"
+                supported={!!props.ios}
+            />
+
+            <LemonDivider vertical className="h-full" />
+            <SupportedPlatform
+                note={isObject(props.reactNative) ? props.reactNative.note : undefined}
+                label="React Native"
+                supported={!!props.reactNative}
+            />
+
+            <LemonDivider vertical className="h-full" />
+            <SupportedPlatform
+                note={isObject(props.flutter) ? props.flutter.note : undefined}
+                label="Flutter"
+                supported={!!props.flutter}
+            />
+        </div>
+    )
+}
+
 function LogCaptureSettings(): JSX.Element {
     const { updateCurrentTeam } = useActions(teamLogic)
     const { currentTeam } = useValues(teamLogic)
@@ -20,6 +103,7 @@ function LogCaptureSettings(): JSX.Element {
     return (
         <div>
             <h3>Log capture</h3>
+            <SupportedPlatforms android={true} ios={true} flutter={true} web={true} reactNative={true} />
             <p>
                 This setting controls if browser console logs will be captured as a part of recordings. The console logs
                 will be shown in the recording player to help you debug any issues.
@@ -52,6 +136,19 @@ function CanvasCaptureSettings(): JSX.Element | null {
     return (
         <div>
             <h3>Canvas capture</h3>
+            <SupportedPlatforms
+                android={false}
+                ios={false}
+                flutter={{
+                    note: (
+                        <>
+                            If you're using the `canvaskit` renderer on Flutter Web, you must also enable canvas capture
+                        </>
+                    ),
+                }}
+                web={true}
+                reactNative={false}
+            />
             <p>
                 This setting controls if browser canvas elements will be captured as part of recordings.{' '}
                 <b>
@@ -111,6 +208,7 @@ export function NetworkCaptureSettings(): JSX.Element {
 
     return (
         <>
+            <SupportedPlatforms android={true} ios={true} flutter={false} web={true} reactNative={false} />
             <p>
                 This setting controls if performance and network information will be captured alongside recordings. The
                 network requests and timings will be shown in the recording player to help you debug any issues.
@@ -140,10 +238,10 @@ export function NetworkCaptureSettings(): JSX.Element {
                         Learn how to mask header and payload values in our docs
                     </Link>
                 </p>
-                <p>Capture headers and body are only available for JavaScript Web.</p>
                 <LemonBanner type="info" className="mb-4">
                     <PayloadWarning />
                 </LemonBanner>
+                <SupportedPlatforms android={false} ios={false} flutter={false} web={true} reactNative={false} />
                 <div className="flex flex-row space-x-2">
                     <LemonSwitch
                         data-attr="opt-in-capture-network-headers-switch"
@@ -217,9 +315,14 @@ export function NetworkCaptureSettings(): JSX.Element {
     )
 }
 
+/**
+ * @deprecated use ReplayTriggers instead, this is only presented to teams that have these settings set
+ * @constructor
+ */
 export function ReplayAuthorizedDomains(): JSX.Element {
     return (
         <div className="space-y-2">
+            <SupportedPlatforms android={false} ios={false} flutter={false} web={true} reactNative={false} />
             <p>
                 Use the settings below to restrict the domains where recordings will be captured. If no domains are
                 selected, then there will be no domain restriction.
@@ -399,6 +502,7 @@ export function ReplayGeneral(): JSX.Element {
     return (
         <div className="flex flex-col gap-4">
             <div>
+                <SupportedPlatforms android={true} ios={true} flutter={true} web={true} reactNative={true} />
                 <p>
                     Watch recordings of how users interact with your web app to see what can be improved.{' '}
                     <Link
diff --git a/frontend/src/scenes/settings/environment/TeamSettings.tsx b/frontend/src/scenes/settings/environment/TeamSettings.tsx
index 94a4ad90c5dcd..07c874202c8a2 100644
--- a/frontend/src/scenes/settings/environment/TeamSettings.tsx
+++ b/frontend/src/scenes/settings/environment/TeamSettings.tsx
@@ -1,11 +1,12 @@
 import { urls } from '@posthog/apps-common'
-import { LemonButton, LemonDialog, LemonInput, LemonLabel, LemonSkeleton } from '@posthog/lemon-ui'
+import { LemonButton, LemonDialog, LemonInput, LemonLabel, LemonSkeleton, LemonTag } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { AuthorizedUrlList } from 'lib/components/AuthorizedUrlList/AuthorizedUrlList'
 import { AuthorizedUrlListType } from 'lib/components/AuthorizedUrlList/authorizedUrlListLogic'
 import { CodeSnippet } from 'lib/components/CodeSnippet'
+import { FlaggedFeature } from 'lib/components/FlaggedFeature'
 import { JSBookmarklet } from 'lib/components/JSBookmarklet'
-import { JSSnippet } from 'lib/components/JSSnippet'
+import { JSSnippet, JSSnippetV2 } from 'lib/components/JSSnippet'
 import { getPublicSupportSnippet } from 'lib/components/Support/supportLogic'
 import { FEATURE_FLAGS } from 'lib/constants'
 import { IconRefresh } from 'lib/lemon-ui/icons'
@@ -66,6 +67,25 @@ export function WebSnippet(): JSX.Element {
             ) : (
                 <JSSnippet />
             )}
+
+            <FlaggedFeature flag="remote-config">
+                <h3 className="mt-4 flex items-center gap-2">
+                    Web Snippet V2 <LemonTag type="warning">Experimental</LemonTag>
+                </h3>
+                <p>
+                    The V2 version of the snippet is more advanced and includes your project config automatically along
+                    with the PostHog JS code. This generally leads to faster load times and fewer calls needed before
+                    the SDK is fully functional.
+                </p>
+                {currentTeamLoading && !currentTeam ? (
+                    <div className="space-y-4">
+                        <LemonSkeleton className="w-1/2 h-4" />
+                        <LemonSkeleton repeat={3} />
+                    </div>
+                ) : (
+                    <JSSnippetV2 />
+                )}
+            </FlaggedFeature>
         </>
     )
 }
diff --git a/frontend/src/scenes/settings/environment/proxyLogic.ts b/frontend/src/scenes/settings/environment/proxyLogic.ts
index d18a07babbf61..e087aee0aa616 100644
--- a/frontend/src/scenes/settings/environment/proxyLogic.ts
+++ b/frontend/src/scenes/settings/environment/proxyLogic.ts
@@ -83,6 +83,8 @@ export const proxyLogic = kea<proxyLogicType>([
                     ? 'Domains cannot include wildcards'
                     : !isDomain('http://' + domain)
                     ? 'Do not include the protocol e.g. https://'
+                    : !domain.match(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/)
+                    ? "Invalid domain. Please provide a lowercase RFC 1123 subdomain. It must consist of lower case alphanumeric characters, '-' or '.', and must start and end with an alphanumeric character"
                     : undefined,
             }),
             submit: ({ domain }) => {
diff --git a/frontend/src/scenes/settings/environment/replayTriggersLogic.ts b/frontend/src/scenes/settings/environment/replayTriggersLogic.ts
new file mode 100644
index 0000000000000..835a38728b731
--- /dev/null
+++ b/frontend/src/scenes/settings/environment/replayTriggersLogic.ts
@@ -0,0 +1,233 @@
+import { actions, connect, kea, listeners, path, reducers, selectors, sharedListeners } from 'kea'
+import { forms } from 'kea-forms'
+import { subscriptions } from 'kea-subscriptions'
+import { teamLogic } from 'scenes/teamLogic'
+
+import { SessionReplayUrlTriggerConfig, TeamPublicType, TeamType } from '~/types'
+
+import type { replayTriggersLogicType } from './replayTriggersLogicType'
+
+const NEW_URL_TRIGGER = { url: '', matching: 'regex' }
+
+function ensureAnchored(url: string): string {
+    url = url.startsWith('^') ? url.substring(1) : url
+    url = url.endsWith('$') ? url.substring(0, url.length - 1) : url
+    return `^${url}$`
+}
+
+export const replayTriggersLogic = kea<replayTriggersLogicType>([
+    path(['scenes', 'settings', 'project', 'replayTriggersLogic']),
+    actions({
+        setUrlTriggerConfig: (urlTriggerConfig: SessionReplayUrlTriggerConfig[]) => ({ urlTriggerConfig }),
+        addUrlTrigger: (urlTriggerConfig: SessionReplayUrlTriggerConfig) => ({ urlTriggerConfig }),
+        removeUrlTrigger: (index: number) => ({ index }),
+        updateUrlTrigger: (index: number, urlTriggerConfig: SessionReplayUrlTriggerConfig) => ({
+            index,
+            urlTriggerConfig,
+        }),
+        setEditUrlTriggerIndex: (originalIndex: number | null) => ({ originalIndex }),
+        newUrlTrigger: true,
+        cancelProposingUrlTrigger: true,
+
+        setUrlBlocklistConfig: (urlBlocklistConfig: SessionReplayUrlTriggerConfig[]) => ({ urlBlocklistConfig }),
+        addUrlBlocklist: (urlBlocklistConfig: SessionReplayUrlTriggerConfig) => ({ urlBlocklistConfig }),
+        removeUrlBlocklist: (index: number) => ({ index }),
+        updateUrlBlocklist: (index: number, urlBlocklistConfig: SessionReplayUrlTriggerConfig) => ({
+            index,
+            urlBlocklistConfig,
+        }),
+        setEditUrlBlocklistIndex: (originalIndex: number | null) => ({ originalIndex }),
+        newUrlBlocklist: true,
+        cancelProposingUrlBlocklist: true,
+        setEventTriggerConfig: (eventTriggerConfig: string[]) => ({ eventTriggerConfig }),
+        updateEventTriggerConfig: (eventTriggerConfig: string[]) => ({ eventTriggerConfig }),
+    }),
+    connect({ values: [teamLogic, ['currentTeam']], actions: [teamLogic, ['updateCurrentTeam']] }),
+    reducers({
+        urlTriggerConfig: [
+            null as SessionReplayUrlTriggerConfig[] | null,
+            {
+                setUrlTriggerConfig: (_, { urlTriggerConfig }) => urlTriggerConfig,
+                addUrlTrigger: (state, { urlTriggerConfig }) => [...(state ?? []), urlTriggerConfig],
+                updateUrlTrigger: (state, { index, urlTriggerConfig: newUrlTriggerConfig }) =>
+                    (state ?? []).map((triggerConfig, i) => (i === index ? newUrlTriggerConfig : triggerConfig)),
+                removeUrlTrigger: (state, { index }) => {
+                    return (state ?? []).filter((_, i) => i !== index)
+                },
+            },
+        ],
+        editUrlTriggerIndex: [
+            null as number | null,
+            {
+                setEditUrlTriggerIndex: (_, { originalIndex }) => originalIndex,
+                removeUrlTrigger: (editUrlTriggerIndex, { index }) =>
+                    editUrlTriggerIndex && index < editUrlTriggerIndex
+                        ? editUrlTriggerIndex - 1
+                        : index === editUrlTriggerIndex
+                        ? null
+                        : editUrlTriggerIndex,
+                newUrlTrigger: () => -1,
+                updateUrlTrigger: () => null,
+                addUrlTrigger: () => null,
+                cancelProposingUrlTrigger: () => null,
+            },
+        ],
+        urlBlocklistConfig: [
+            null as SessionReplayUrlTriggerConfig[] | null,
+            {
+                setUrlBlocklistConfig: (_, { urlBlocklistConfig }) => urlBlocklistConfig,
+                addUrlBlocklist: (state, { urlBlocklistConfig }) => [...(state ?? []), urlBlocklistConfig],
+                updateUrlBlocklist: (state, { index, urlBlocklistConfig: newUrlBlocklistConfig }) =>
+                    (state ?? []).map((blocklistConfig, i) => (i === index ? newUrlBlocklistConfig : blocklistConfig)),
+                removeUrlBlocklist: (state, { index }) => {
+                    return (state ?? []).filter((_, i) => i !== index)
+                },
+            },
+        ],
+        editUrlBlocklistIndex: [
+            null as number | null,
+            {
+                setEditUrlBlocklistIndex: (_, { originalIndex }) => originalIndex,
+                removeUrlBlocklist: (editUrlBlocklistIndex, { index }) =>
+                    editUrlBlocklistIndex && index < editUrlBlocklistIndex
+                        ? editUrlBlocklistIndex - 1
+                        : index === editUrlBlocklistIndex
+                        ? null
+                        : editUrlBlocklistIndex,
+                newUrlBlocklist: () => -1,
+                updateUrlBlocklist: () => null,
+                addUrlBlocklist: () => null,
+            },
+        ],
+        eventTriggerConfig: [
+            null as string[] | null,
+            {
+                setEventTriggerConfig: (_, { eventTriggerConfig }) => eventTriggerConfig,
+                updateEventTriggerConfig: (_, { eventTriggerConfig }) => eventTriggerConfig,
+            },
+        ],
+    }),
+    selectors({
+        remoteUrlTriggerConfig: [
+            (s) => [s.currentTeam],
+            (currentTeam) => currentTeam?.session_recording_url_trigger_config,
+        ],
+        isAddUrlTriggerConfigFormVisible: [
+            (s) => [s.editUrlTriggerIndex],
+            (editUrlTriggerIndex) => editUrlTriggerIndex === -1,
+        ],
+        urlTriggerToEdit: [
+            (s) => [s.urlTriggerConfig, s.editUrlTriggerIndex],
+            (urlTriggerConfig, editUrlTriggerIndex) => {
+                if (
+                    editUrlTriggerIndex === null ||
+                    editUrlTriggerIndex === -1 ||
+                    !urlTriggerConfig?.[editUrlTriggerIndex]
+                ) {
+                    return NEW_URL_TRIGGER
+                }
+                return urlTriggerConfig[editUrlTriggerIndex]
+            },
+        ],
+
+        remoteUrlBlocklistConfig: [
+            (s) => [s.currentTeam],
+            (currentTeam) => currentTeam?.session_recording_url_blocklist_config,
+        ],
+        isAddUrlBlocklistConfigFormVisible: [
+            (s) => [s.editUrlBlocklistIndex],
+            (editUrlBlocklistIndex) => editUrlBlocklistIndex === -1,
+        ],
+        urlBlocklistToEdit: [
+            (s) => [s.urlBlocklistConfig, s.editUrlBlocklistIndex],
+            (urlBlocklistConfig, editUrlBlocklistIndex) => {
+                if (
+                    editUrlBlocklistIndex === null ||
+                    editUrlBlocklistIndex === -1 ||
+                    !urlBlocklistConfig?.[editUrlBlocklistIndex]
+                ) {
+                    return NEW_URL_TRIGGER
+                }
+                return urlBlocklistConfig[editUrlBlocklistIndex]
+            },
+        ],
+    }),
+    subscriptions(({ actions }) => ({
+        currentTeam: (currentTeam: TeamPublicType | TeamType | null) => {
+            actions.setUrlTriggerConfig(currentTeam?.session_recording_url_trigger_config ?? [])
+            actions.setUrlBlocklistConfig(currentTeam?.session_recording_url_blocklist_config ?? [])
+            actions.setEventTriggerConfig(currentTeam?.session_recording_event_trigger_config ?? [])
+        },
+    })),
+    forms(({ values, actions }) => ({
+        proposedUrlTrigger: {
+            defaults: { url: '', matching: 'regex' } as SessionReplayUrlTriggerConfig,
+            errors: ({ url }) => ({
+                url: !url ? 'Must have a URL' : undefined,
+            }),
+            submit: async ({ url, matching }) => {
+                if (values.editUrlTriggerIndex !== null && values.editUrlTriggerIndex >= 0) {
+                    actions.updateUrlTrigger(values.editUrlTriggerIndex, { url: ensureAnchored(url), matching })
+                } else {
+                    actions.addUrlTrigger({ url: ensureAnchored(url), matching })
+                }
+            },
+        },
+        proposedUrlBlocklist: {
+            defaults: { url: '', matching: 'regex' } as SessionReplayUrlTriggerConfig,
+            errors: ({ url }) => ({
+                url: !url ? 'Must have a URL' : undefined,
+            }),
+            submit: async ({ url, matching }) => {
+                if (values.editUrlBlocklistIndex !== null && values.editUrlBlocklistIndex >= 0) {
+                    actions.updateUrlBlocklist(values.editUrlBlocklistIndex, { url: ensureAnchored(url), matching })
+                } else {
+                    actions.addUrlBlocklist({ url: ensureAnchored(url), matching })
+                }
+            },
+        },
+    })),
+    sharedListeners(({ values }) => ({
+        saveUrlTriggers: async () => {
+            await teamLogic.asyncActions.updateCurrentTeam({
+                session_recording_url_trigger_config: values.urlTriggerConfig ?? [],
+            })
+        },
+        saveUrlBlocklists: async () => {
+            await teamLogic.asyncActions.updateCurrentTeam({
+                session_recording_url_blocklist_config: values.urlBlocklistConfig ?? [],
+            })
+        },
+    })),
+    listeners(({ sharedListeners, actions, values }) => ({
+        setEditUrlTriggerIndex: () => {
+            actions.setProposedUrlTriggerValue('url', values.urlTriggerToEdit.url)
+            actions.setProposedUrlTriggerValue('matching', values.urlTriggerToEdit.matching)
+        },
+        addUrlTrigger: sharedListeners.saveUrlTriggers,
+        removeUrlTrigger: sharedListeners.saveUrlTriggers,
+        updateUrlTrigger: sharedListeners.saveUrlTriggers,
+        submitProposedUrlTriggerSuccess: () => {
+            actions.setEditUrlTriggerIndex(null)
+            actions.resetProposedUrlTrigger()
+        },
+
+        setEditUrlBlocklistIndex: () => {
+            actions.setProposedUrlBlocklistValue('url', values.urlBlocklistToEdit.url)
+            actions.setProposedUrlBlocklistValue('matching', values.urlBlocklistToEdit.matching)
+        },
+        addUrlBlocklist: sharedListeners.saveUrlBlocklists,
+        removeUrlBlocklist: sharedListeners.saveUrlBlocklists,
+        updateUrlBlocklist: sharedListeners.saveUrlBlocklists,
+        submitProposedUrlBlocklistSuccess: () => {
+            actions.setEditUrlBlocklistIndex(null)
+            actions.resetProposedUrlBlocklist()
+        },
+        updateEventTriggerConfig: async ({ eventTriggerConfig }) => {
+            actions.setEventTriggerConfig(eventTriggerConfig)
+            await teamLogic.asyncActions.updateCurrentTeam({
+                session_recording_event_trigger_config: eventTriggerConfig,
+            })
+        },
+    })),
+])
diff --git a/frontend/src/scenes/settings/environment/sessionReplayIngestionControlLogic.ts b/frontend/src/scenes/settings/environment/sessionReplayIngestionControlLogic.ts
index 9432c128ac681..a5a66ad5891ec 100644
--- a/frontend/src/scenes/settings/environment/sessionReplayIngestionControlLogic.ts
+++ b/frontend/src/scenes/settings/environment/sessionReplayIngestionControlLogic.ts
@@ -1,46 +1,18 @@
-import { actions, afterMount, connect, kea, listeners, path, props, reducers, selectors, sharedListeners } from 'kea'
-import { forms } from 'kea-forms'
+import { actions, afterMount, connect, kea, path, reducers, selectors } from 'kea'
 import { loaders } from 'kea-loaders'
-import { subscriptions } from 'kea-subscriptions'
 import api from 'lib/api'
 import { isObject } from 'lib/utils'
 import { variantKeyToIndexFeatureFlagPayloads } from 'scenes/feature-flags/featureFlagLogic'
 import { teamLogic } from 'scenes/teamLogic'
 
-import { FeatureFlagBasicType, SessionReplayUrlTriggerConfig, TeamPublicType, TeamType } from '~/types'
+import { FeatureFlagBasicType } from '~/types'
 
 import type { sessionReplayIngestionControlLogicType } from './sessionReplayIngestionControlLogicType'
 
-const NEW_URL_TRIGGER = { url: '', matching: 'regex' }
-
 export const sessionReplayIngestionControlLogic = kea<sessionReplayIngestionControlLogicType>([
     path(['scenes', 'settings', 'project', 'sessionReplayIngestionControlLogic']),
     actions({
         selectFeatureFlag: (flag: FeatureFlagBasicType) => ({ flag }),
-
-        setUrlTriggerConfig: (urlTriggerConfig: SessionReplayUrlTriggerConfig[]) => ({ urlTriggerConfig }),
-        addUrlTrigger: (urlTriggerConfig: SessionReplayUrlTriggerConfig) => ({ urlTriggerConfig }),
-        removeUrlTrigger: (index: number) => ({ index }),
-        updateUrlTrigger: (index: number, urlTriggerConfig: SessionReplayUrlTriggerConfig) => ({
-            index,
-            urlTriggerConfig,
-        }),
-        setEditUrlTriggerIndex: (originalIndex: number | null) => ({ originalIndex }),
-        newUrlTrigger: true,
-        cancelProposingUrlTrigger: true,
-
-        setUrlBlocklistConfig: (urlBlocklistConfig: SessionReplayUrlTriggerConfig[]) => ({ urlBlocklistConfig }),
-        addUrlBlocklist: (urlBlocklistConfig: SessionReplayUrlTriggerConfig) => ({ urlBlocklistConfig }),
-        removeUrlBlocklist: (index: number) => ({ index }),
-        updateUrlBlocklist: (index: number, urlBlocklistConfig: SessionReplayUrlTriggerConfig) => ({
-            index,
-            urlBlocklistConfig,
-        }),
-        setEditUrlBlocklistIndex: (originalIndex: number | null) => ({ originalIndex }),
-        newUrlBlocklist: true,
-        cancelProposingUrlBlocklist: true,
-        setEventTriggerConfig: (eventTriggerConfig: string[]) => ({ eventTriggerConfig }),
-        updateEventTriggerConfig: (eventTriggerConfig: string[]) => ({ eventTriggerConfig }),
     }),
     connect({ values: [teamLogic, ['currentTeam']], actions: [teamLogic, ['updateCurrentTeam']] }),
     reducers({
@@ -50,70 +22,7 @@ export const sessionReplayIngestionControlLogic = kea<sessionReplayIngestionCont
                 selectFeatureFlag: (_, { flag }) => flag,
             },
         ],
-        urlTriggerConfig: [
-            null as SessionReplayUrlTriggerConfig[] | null,
-            {
-                setUrlTriggerConfig: (_, { urlTriggerConfig }) => urlTriggerConfig,
-                addUrlTrigger: (state, { urlTriggerConfig }) => [...(state ?? []), urlTriggerConfig],
-                updateUrlTrigger: (state, { index, urlTriggerConfig: newUrlTriggerConfig }) =>
-                    (state ?? []).map((triggerConfig, i) => (i === index ? newUrlTriggerConfig : triggerConfig)),
-                removeUrlTrigger: (state, { index }) => {
-                    return (state ?? []).filter((_, i) => i !== index)
-                },
-            },
-        ],
-        editUrlTriggerIndex: [
-            null as number | null,
-            {
-                setEditUrlTriggerIndex: (_, { originalIndex }) => originalIndex,
-                removeUrlTrigger: (editUrlTriggerIndex, { index }) =>
-                    editUrlTriggerIndex && index < editUrlTriggerIndex
-                        ? editUrlTriggerIndex - 1
-                        : index === editUrlTriggerIndex
-                        ? null
-                        : editUrlTriggerIndex,
-                newUrlTrigger: () => -1,
-                updateUrlTrigger: () => null,
-                addUrlTrigger: () => null,
-                cancelProposingUrlTrigger: () => null,
-            },
-        ],
-        urlBlocklistConfig: [
-            null as SessionReplayUrlTriggerConfig[] | null,
-            {
-                setUrlBlocklistConfig: (_, { urlBlocklistConfig }) => urlBlocklistConfig,
-                addUrlBlocklist: (state, { urlBlocklistConfig }) => [...(state ?? []), urlBlocklistConfig],
-                updateUrlBlocklist: (state, { index, urlBlocklistConfig: newUrlBlocklistConfig }) =>
-                    (state ?? []).map((blocklistConfig, i) => (i === index ? newUrlBlocklistConfig : blocklistConfig)),
-                removeUrlBlocklist: (state, { index }) => {
-                    return (state ?? []).filter((_, i) => i !== index)
-                },
-            },
-        ],
-        editUrlBlocklistIndex: [
-            null as number | null,
-            {
-                setEditUrlBlocklistIndex: (_, { originalIndex }) => originalIndex,
-                removeUrlBlocklist: (editUrlBlocklistIndex, { index }) =>
-                    editUrlBlocklistIndex && index < editUrlBlocklistIndex
-                        ? editUrlBlocklistIndex - 1
-                        : index === editUrlBlocklistIndex
-                        ? null
-                        : editUrlBlocklistIndex,
-                newUrlBlocklist: () => -1,
-                updateUrlBlocklist: () => null,
-                addUrlBlocklist: () => null,
-            },
-        ],
-        eventTriggerConfig: [
-            null as string[] | null,
-            {
-                setEventTriggerConfig: (_, { eventTriggerConfig }) => eventTriggerConfig,
-                updateEventTriggerConfig: (_, { eventTriggerConfig }) => eventTriggerConfig,
-            },
-        ],
     }),
-    props({}),
     loaders(({ values }) => ({
         featureFlag: {
             loadFeatureFlag: async () => {
@@ -140,124 +49,8 @@ export const sessionReplayIngestionControlLogic = kea<sessionReplayIngestionCont
                 currentTeam?.session_recording_linked_flag?.id ? selectedFlag || featureFlag : null,
         ],
         flagHasVariants: [(s) => [s.linkedFlag], (linkedFlag) => isObject(linkedFlag?.filters.multivariate)],
-
-        remoteUrlTriggerConfig: [
-            (s) => [s.currentTeam],
-            (currentTeam) => currentTeam?.session_recording_url_trigger_config,
-        ],
-        isAddUrlTriggerConfigFormVisible: [
-            (s) => [s.editUrlTriggerIndex],
-            (editUrlTriggerIndex) => editUrlTriggerIndex === -1,
-        ],
-        urlTriggerToEdit: [
-            (s) => [s.urlTriggerConfig, s.editUrlTriggerIndex],
-            (urlTriggerConfig, editUrlTriggerIndex) => {
-                if (
-                    editUrlTriggerIndex === null ||
-                    editUrlTriggerIndex === -1 ||
-                    !urlTriggerConfig?.[editUrlTriggerIndex]
-                ) {
-                    return NEW_URL_TRIGGER
-                }
-                return urlTriggerConfig[editUrlTriggerIndex]
-            },
-        ],
-
-        remoteUrlBlocklistConfig: [
-            (s) => [s.currentTeam],
-            (currentTeam) => currentTeam?.session_recording_url_blocklist_config,
-        ],
-        isAddUrlBlocklistConfigFormVisible: [
-            (s) => [s.editUrlBlocklistIndex],
-            (editUrlBlocklistIndex) => editUrlBlocklistIndex === -1,
-        ],
-        urlBlocklistToEdit: [
-            (s) => [s.urlBlocklistConfig, s.editUrlBlocklistIndex],
-            (urlBlocklistConfig, editUrlBlocklistIndex) => {
-                if (
-                    editUrlBlocklistIndex === null ||
-                    editUrlBlocklistIndex === -1 ||
-                    !urlBlocklistConfig?.[editUrlBlocklistIndex]
-                ) {
-                    return NEW_URL_TRIGGER
-                }
-                return urlBlocklistConfig[editUrlBlocklistIndex]
-            },
-        ],
     }),
     afterMount(({ actions }) => {
         actions.loadFeatureFlag()
     }),
-    subscriptions(({ actions }) => ({
-        currentTeam: (currentTeam: TeamPublicType | TeamType | null) => {
-            actions.setUrlTriggerConfig(currentTeam?.session_recording_url_trigger_config ?? [])
-            actions.setUrlBlocklistConfig(currentTeam?.session_recording_url_blocklist_config ?? [])
-            actions.setEventTriggerConfig(currentTeam?.session_recording_event_trigger_config ?? [])
-        },
-    })),
-    forms(({ values, actions }) => ({
-        proposedUrlTrigger: {
-            defaults: { url: '', matching: 'regex' } as SessionReplayUrlTriggerConfig,
-            submit: async ({ url, matching }) => {
-                if (values.editUrlTriggerIndex !== null && values.editUrlTriggerIndex >= 0) {
-                    actions.updateUrlTrigger(values.editUrlTriggerIndex, { url, matching })
-                } else {
-                    actions.addUrlTrigger({ url, matching })
-                }
-            },
-        },
-        proposedUrlBlocklist: {
-            defaults: { url: '', matching: 'regex' } as SessionReplayUrlTriggerConfig,
-            submit: async ({ url, matching }) => {
-                if (values.editUrlBlocklistIndex !== null && values.editUrlBlocklistIndex >= 0) {
-                    actions.updateUrlBlocklist(values.editUrlBlocklistIndex, { url, matching })
-                } else {
-                    actions.addUrlBlocklist({ url, matching })
-                }
-            },
-        },
-    })),
-    sharedListeners(({ values }) => ({
-        saveUrlTriggers: async () => {
-            await teamLogic.asyncActions.updateCurrentTeam({
-                session_recording_url_trigger_config: values.urlTriggerConfig ?? [],
-            })
-        },
-        saveUrlBlocklists: async () => {
-            await teamLogic.asyncActions.updateCurrentTeam({
-                session_recording_url_blocklist_config: values.urlBlocklistConfig ?? [],
-            })
-        },
-    })),
-    listeners(({ sharedListeners, actions, values }) => ({
-        setEditUrlTriggerIndex: () => {
-            actions.setProposedUrlTriggerValue('url', values.urlTriggerToEdit.url)
-            actions.setProposedUrlTriggerValue('matching', values.urlTriggerToEdit.matching)
-        },
-        addUrlTrigger: sharedListeners.saveUrlTriggers,
-        removeUrlTrigger: sharedListeners.saveUrlTriggers,
-        updateUrlTrigger: sharedListeners.saveUrlTriggers,
-        submitProposedUrlTriggerSuccess: () => {
-            actions.setEditUrlTriggerIndex(null)
-            actions.resetProposedUrlTrigger()
-        },
-
-        setEditUrlBlocklistIndex: () => {
-            actions.setProposedUrlBlocklistValue('url', values.urlBlocklistToEdit.url)
-            actions.setProposedUrlBlocklistValue('matching', values.urlBlocklistToEdit.matching)
-        },
-        addUrlBlocklist: sharedListeners.saveUrlBlocklists,
-        removeUrlBlocklist: sharedListeners.saveUrlBlocklists,
-        updateUrlBlocklist: sharedListeners.saveUrlBlocklists,
-        submitProposedUrlBlocklistSuccess: () => {
-            actions.setEditUrlBlocklistIndex(null)
-            actions.resetProposedUrlBlocklist()
-        },
-        updateEventTriggerConfig: async ({ eventTriggerConfig }) => {
-            actions.setEventTriggerConfig(eventTriggerConfig)
-            await teamLogic.asyncActions.updateCurrentTeam({
-                session_recording_event_trigger_config: eventTriggerConfig,
-            })
-        },
-    })),
 ])
diff --git a/frontend/src/scenes/settings/organization/Members.tsx b/frontend/src/scenes/settings/organization/Members.tsx
index cceeaa73e538d..997582fa81982 100644
--- a/frontend/src/scenes/settings/organization/Members.tsx
+++ b/frontend/src/scenes/settings/organization/Members.tsx
@@ -1,4 +1,4 @@
-import { LemonInput, LemonModal, LemonSwitch } from '@posthog/lemon-ui'
+import { LemonInput, LemonSwitch } from '@posthog/lemon-ui'
 import { useActions, useValues } from 'kea'
 import { PayGateMini } from 'lib/components/PayGateMini/PayGateMini'
 import { TZLabel } from 'lib/components/TZLabel'
@@ -17,8 +17,8 @@ import {
     membershipLevelToName,
     organizationMembershipLevelIntegers,
 } from 'lib/utils/permissioning'
-import { useEffect, useState } from 'react'
-import { Setup2FA } from 'scenes/authentication/Setup2FA'
+import { useEffect } from 'react'
+import { twoFactorLogic } from 'scenes/authentication/twoFactorLogic'
 import { membersLogic } from 'scenes/organization/membersLogic'
 import { organizationLogic } from 'scenes/organizationLogic'
 import { preflightLogic } from 'scenes/PreflightCheck/preflightLogic'
@@ -138,13 +138,14 @@ function ActionsComponent(_: any, member: OrganizationMemberType): JSX.Element |
 
 export function Members(): JSX.Element | null {
     const { filteredMembers, membersLoading, search } = useValues(membersLogic)
-    const { setSearch, ensureAllMembersLoaded, loadAllMembers } = useActions(membersLogic)
     const { currentOrganization } = useValues(organizationLogic)
-    const { updateOrganization } = useActions(organizationLogic)
-    const [is2FAModalVisible, set2FAModalVisible] = useState(false)
     const { preflight } = useValues(preflightLogic)
     const { user } = useValues(userLogic)
 
+    const { setSearch, ensureAllMembersLoaded } = useActions(membersLogic)
+    const { updateOrganization } = useActions(organizationLogic)
+    const { openTwoFactorSetupModal } = useActions(twoFactorLogic)
+
     useEffect(() => {
         ensureAllMembersLoaded()
     }, [])
@@ -210,17 +211,6 @@ export function Members(): JSX.Element | null {
             render: function LevelRender(_, member) {
                 return (
                     <>
-                        {member.user.uuid == user.uuid && is2FAModalVisible && (
-                            <LemonModal title="Set up or manage 2FA" onClose={() => set2FAModalVisible(false)}>
-                                <Setup2FA
-                                    onSuccess={() => {
-                                        set2FAModalVisible(false)
-                                        userLogic.actions.updateUser({})
-                                        loadAllMembers()
-                                    }}
-                                />
-                            </LemonModal>
-                        )}
                         <Tooltip
                             title={
                                 member.user.uuid == user.uuid && !member.is_2fa_enabled
@@ -231,7 +221,7 @@ export function Members(): JSX.Element | null {
                             <LemonTag
                                 onClick={
                                     member.user.uuid == user.uuid && !member.is_2fa_enabled
-                                        ? () => set2FAModalVisible(true)
+                                        ? () => openTwoFactorSetupModal()
                                         : undefined
                                 }
                                 data-attr="2fa-enabled"
diff --git a/frontend/src/scenes/settings/organization/VerifiedDomains/__snapshots__/verifiedDomainsLogic.test.ts.snap b/frontend/src/scenes/settings/organization/VerifiedDomains/__snapshots__/verifiedDomainsLogic.test.ts.snap
index 01691f9675451..47c205486a7e8 100644
--- a/frontend/src/scenes/settings/organization/VerifiedDomains/__snapshots__/verifiedDomainsLogic.test.ts.snap
+++ b/frontend/src/scenes/settings/organization/VerifiedDomains/__snapshots__/verifiedDomainsLogic.test.ts.snap
@@ -115,6 +115,7 @@ exports[`verifiedDomainsLogic values has proper defaults 1`] = `
         "test_account_filters_default_checked": false,
         "timezone": "UTC",
         "updated_at": "2022-03-17T16:09:21.566253Z",
+        "user_access_level": "admin",
         "uuid": "TEAM_UUID",
       },
     ],
diff --git a/frontend/src/scenes/settings/organization/VerifiedDomains/verifiedDomainsLogic.ts b/frontend/src/scenes/settings/organization/VerifiedDomains/verifiedDomainsLogic.ts
index de997f5d7b1cc..90ad7dc2d0435 100644
--- a/frontend/src/scenes/settings/organization/VerifiedDomains/verifiedDomainsLogic.ts
+++ b/frontend/src/scenes/settings/organization/VerifiedDomains/verifiedDomainsLogic.ts
@@ -78,9 +78,12 @@ export const verifiedDomainsLogic = kea<verifiedDomainsLogicType>([
                     (await api.get(`api/organizations/${values.currentOrganization?.id}/domains`))
                         .results as OrganizationDomainType[],
                 addVerifiedDomain: async (domain: string) => {
-                    const response = await api.create(`api/organizations/${values.currentOrganization?.id}/domains`, {
-                        domain,
-                    })
+                    const response = await api.create<OrganizationDomainType>(
+                        `api/organizations/${values.currentOrganization?.id}/domains`,
+                        {
+                            domain,
+                        }
+                    )
                     return [response, ...values.verifiedDomains]
                 },
                 deleteVerifiedDomain: async (id: string) => {
@@ -93,18 +96,18 @@ export const verifiedDomainsLogic = kea<verifiedDomainsLogicType>([
             false,
             {
                 updateDomain: async (payload: OrganizationDomainUpdatePayload) => {
-                    const response = await api.update(
+                    const response = await api.update<OrganizationDomainType>(
                         `api/organizations/${values.currentOrganization?.id}/domains/${payload.id}`,
                         { ...payload, id: undefined }
                     )
                     lemonToast.success('Domain updated successfully! Changes will take immediately.')
-                    actions.replaceDomain(response as OrganizationDomainType)
+                    actions.replaceDomain(response)
                     return false
                 },
                 verifyDomain: async () => {
-                    const response = (await api.create(
+                    const response = await api.create<OrganizationDomainType>(
                         `api/organizations/${values.currentOrganization?.id}/domains/${values.verifyModal}/verify`
-                    )) as OrganizationDomainType
+                    )
                     if (response.is_verified) {
                         lemonToast.success('Domain verified successfully.')
                     } else {
@@ -158,12 +161,12 @@ export const verifiedDomainsLogic = kea<verifiedDomainsLogicType>([
                 if (!id) {
                     return
                 }
-                const response = (await api.update(
+                const response = await api.update<OrganizationDomainType>(
                     `api/organizations/${values.currentOrganization?.id}/domains/${payload.id}`,
                     {
                         ...updateParams,
                     }
-                )) as OrganizationDomainType
+                )
                 breakpoint()
                 actions.replaceDomain(response)
                 actions.setConfigureSAMLModalId(null)
diff --git a/frontend/src/scenes/settings/organization/inviteLogic.ts b/frontend/src/scenes/settings/organization/inviteLogic.ts
index 878961f7332bf..3492c95ab2be1 100644
--- a/frontend/src/scenes/settings/organization/inviteLogic.ts
+++ b/frontend/src/scenes/settings/organization/inviteLogic.ts
@@ -1,7 +1,7 @@
 import { actions, connect, events, kea, listeners, path, reducers, selectors } from 'kea'
 import { loaders } from 'kea-loaders'
 import { router, urlToAction } from 'kea-router'
-import api from 'lib/api'
+import api, { PaginatedResponse } from 'lib/api'
 import { OrganizationMembershipLevel } from 'lib/constants'
 import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
 import { organizationLogic } from 'scenes/organizationLogic'
@@ -49,7 +49,7 @@ export const inviteLogic = kea<inviteLogicType>([
             {
                 inviteTeamMembers: async () => {
                     if (!values.canSubmit) {
-                        return { invites: [] }
+                        return []
                     }
 
                     const payload: Pick<OrganizationInviteType, 'target_email' | 'first_name' | 'level' | 'message'>[] =
@@ -57,7 +57,10 @@ export const inviteLogic = kea<inviteLogicType>([
                     if (values.message) {
                         payload.forEach((payload) => (payload.message = values.message))
                     }
-                    return await api.create('api/organizations/@current/invites/bulk/', payload)
+                    return await api.create<OrganizationInviteType[]>(
+                        'api/organizations/@current/invites/bulk/',
+                        payload
+                    )
                 },
             },
         ],
@@ -66,7 +69,11 @@ export const inviteLogic = kea<inviteLogicType>([
             {
                 loadInvites: async () => {
                     return organizationLogic.values.currentOrganization
-                        ? (await api.get('api/organizations/@current/invites/')).results
+                        ? (
+                              await api.get<PaginatedResponse<OrganizationInviteType>>(
+                                  'api/organizations/@current/invites/'
+                              )
+                          ).results
                         : []
                 },
                 deleteInvite: async (invite: OrganizationInviteType) => {
diff --git a/frontend/src/scenes/settings/settingsLogic.ts b/frontend/src/scenes/settings/settingsLogic.ts
index b2707e0ce71c4..c850cba129c3f 100644
--- a/frontend/src/scenes/settings/settingsLogic.ts
+++ b/frontend/src/scenes/settings/settingsLogic.ts
@@ -3,6 +3,7 @@ import { FEATURE_FLAGS } from 'lib/constants'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { copyToClipboard } from 'lib/utils/copyToClipboard'
 import { preflightLogic } from 'scenes/PreflightCheck/preflightLogic'
+import { teamLogic } from 'scenes/teamLogic'
 import { urls } from 'scenes/urls'
 import { userLogic } from 'scenes/userLogic'
 
@@ -17,7 +18,16 @@ export const settingsLogic = kea<settingsLogicType>([
     key((props) => props.logicKey ?? 'global'),
     path((key) => ['scenes', 'settings', 'settingsLogic', key]),
     connect({
-        values: [featureFlagLogic, ['featureFlags'], userLogic, ['hasAvailableFeature'], preflightLogic, ['preflight']],
+        values: [
+            featureFlagLogic,
+            ['featureFlags'],
+            userLogic,
+            ['hasAvailableFeature'],
+            preflightLogic,
+            ['preflight'],
+            teamLogic,
+            ['currentTeam'],
+        ],
     }),
 
     actions({
@@ -29,14 +39,14 @@ export const settingsLogic = kea<settingsLogicType>([
     }),
 
     reducers(({ props }) => ({
-        selectedLevel: [
+        selectedLevelRaw: [
             (props.settingLevelId ?? 'project') as SettingLevelId,
             {
                 selectLevel: (_, { level }) => level,
                 selectSection: (_, { level }) => level,
             },
         ],
-        selectedSectionId: [
+        selectedSectionIdRaw: [
             (props.sectionId ?? null) as SettingSectionId | null,
             {
                 selectLevel: () => null,
@@ -94,6 +104,40 @@ export const settingsLogic = kea<settingsLogicType>([
                 return sections
             },
         ],
+        selectedLevel: [
+            (s) => [s.selectedLevelRaw, s.selectedSectionIdRaw, s.featureFlags],
+            (selectedLevelRaw, selectedSectionIdRaw, featureFlags): SettingLevelId => {
+                // As of middle of September 2024, `details` and `danger-zone` are the only sections present
+                // at both Environment and Project levels. Others we want to redirect based on the feature flag.
+                if (
+                    !selectedSectionIdRaw ||
+                    (!selectedSectionIdRaw.endsWith('-details') && !selectedSectionIdRaw.endsWith('-danger-zone'))
+                ) {
+                    if (featureFlags[FEATURE_FLAGS.ENVIRONMENTS]) {
+                        return selectedLevelRaw === 'project' ? 'environment' : selectedLevelRaw
+                    }
+                    return selectedLevelRaw === 'environment' ? 'project' : selectedLevelRaw
+                }
+                return selectedLevelRaw
+            },
+        ],
+        selectedSectionId: [
+            (s) => [s.selectedSectionIdRaw, s.featureFlags],
+            (selectedSectionIdRaw, featureFlags): SettingSectionId | null => {
+                if (!selectedSectionIdRaw) {
+                    return null
+                }
+                // As of middle of September 2024, `details` and `danger-zone` are the only sections present
+                // at both Environment and Project levels. Others we want to redirect based on the feature flag.
+                if (!selectedSectionIdRaw.endsWith('-details') && !selectedSectionIdRaw.endsWith('-danger-zone')) {
+                    if (featureFlags[FEATURE_FLAGS.ENVIRONMENTS]) {
+                        return selectedSectionIdRaw.replace(/^project/, 'environment') as SettingSectionId
+                    }
+                    return selectedSectionIdRaw.replace(/^environment/, 'project') as SettingSectionId
+                }
+                return selectedSectionIdRaw
+            },
+        ],
         selectedSection: [
             (s) => [s.sections, s.selectedSectionId],
             (sections, selectedSectionId): SettingSection | null => {
@@ -101,8 +145,24 @@ export const settingsLogic = kea<settingsLogicType>([
             },
         ],
         settings: [
-            (s) => [s.selectedLevel, s.selectedSectionId, s.sections, s.settingId, s.doesMatchFlags, s.preflight],
-            (selectedLevel, selectedSectionId, sections, settingId, doesMatchFlags, preflight): Setting[] => {
+            (s) => [
+                s.selectedLevel,
+                s.selectedSectionId,
+                s.sections,
+                s.settingId,
+                s.doesMatchFlags,
+                s.preflight,
+                s.currentTeam,
+            ],
+            (
+                selectedLevel,
+                selectedSectionId,
+                sections,
+                settingId,
+                doesMatchFlags,
+                preflight,
+                currentTeam
+            ): Setting[] => {
                 let settings: Setting[] = []
 
                 if (selectedSectionId) {
@@ -124,6 +184,9 @@ export const settingsLogic = kea<settingsLogicType>([
                     if (x.hideOn?.includes(Realm.Cloud) && preflight?.cloud) {
                         return false
                     }
+                    if (x.allowForTeam) {
+                        return x.allowForTeam(currentTeam)
+                    }
                     return true
                 })
             },
diff --git a/frontend/src/scenes/settings/settingsSceneLogic.ts b/frontend/src/scenes/settings/settingsSceneLogic.ts
index ac429fd3f3f9b..0813661d4c988 100644
--- a/frontend/src/scenes/settings/settingsSceneLogic.ts
+++ b/frontend/src/scenes/settings/settingsSceneLogic.ts
@@ -51,6 +51,7 @@ export const settingsSceneLogic = kea<settingsSceneLogicType>([
 
             // As of middle of September 2024, `details` and `danger-zone` are the only sections present
             // at both Environment and Project levels. Others we want to redirect based on the feature flag.
+            // This is just for URLs, since analogous logic for _rendering_ settings is already in settingsLogic.
             if (!section.endsWith('-details') && !section.endsWith('-danger-zone')) {
                 if (values.featureFlags[FEATURE_FLAGS.ENVIRONMENTS]) {
                     section = section.replace(/^project/, 'environment')
@@ -73,16 +74,20 @@ export const settingsSceneLogic = kea<settingsSceneLogicType>([
     })),
 
     actionToUrl(({ values }) => ({
+        // Replacing history item instead of pushing, so that the environments<>project redirect doesn't affect history
         selectLevel({ level }) {
-            return [urls.settings(level), router.values.searchParams, router.values.hashParams]
+            return [urls.settings(level), router.values.searchParams, router.values.hashParams, { replace: true }]
         },
         selectSection({ section }) {
-            return [urls.settings(section), router.values.searchParams, router.values.hashParams]
+            return [urls.settings(section), router.values.searchParams, router.values.hashParams, { replace: true }]
         },
         selectSetting({ setting }) {
-            const url = urls.settings(values.selectedSectionId ?? values.selectedLevel, setting)
-
-            return [url]
+            return [
+                urls.settings(values.selectedSectionId ?? values.selectedLevel, setting),
+                undefined,
+                undefined,
+                { replace: true },
+            ]
         },
     })),
 ])
diff --git a/frontend/src/scenes/settings/types.ts b/frontend/src/scenes/settings/types.ts
index fa210a263e20c..0103298077232 100644
--- a/frontend/src/scenes/settings/types.ts
+++ b/frontend/src/scenes/settings/types.ts
@@ -1,6 +1,6 @@
 import { EitherMembershipLevel, FEATURE_FLAGS } from 'lib/constants'
 
-import { Realm } from '~/types'
+import { Realm, TeamPublicType, TeamType } from '~/types'
 
 export type SettingsLogicProps = {
     logicKey?: string
@@ -46,6 +46,7 @@ export type SettingSectionId =
     | 'user-customization'
 
 export type SettingId =
+    | 'replay-triggers'
     | 'display-name'
     | 'snippet'
     | 'bookmarklet'
@@ -115,6 +116,11 @@ export type Setting = {
      */
     flag?: FeatureFlagKey | `!${FeatureFlagKey}` | (FeatureFlagKey | `!${FeatureFlagKey}`)[]
     hideOn?: Realm[]
+    /**
+     * defaults to true if not provided
+     * can check if a team should have access to a setting and return false if not
+     */
+    allowForTeam?: (team: TeamType | TeamPublicType | null) => boolean
 }
 
 export interface SettingSection extends Pick<Setting, 'flag'> {
diff --git a/frontend/src/scenes/settings/user/TwoFactorAuthentication.tsx b/frontend/src/scenes/settings/user/TwoFactorAuthentication.tsx
deleted file mode 100644
index dd23b4e81e0b0..0000000000000
--- a/frontend/src/scenes/settings/user/TwoFactorAuthentication.tsx
+++ /dev/null
@@ -1,149 +0,0 @@
-import { IconCheckCircle, IconCopy, IconWarning } from '@posthog/icons'
-import { LemonButton, LemonModal } from '@posthog/lemon-ui'
-import { useActions, useValues } from 'kea'
-import { FEATURE_FLAGS } from 'lib/constants'
-import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
-import { copyToClipboard } from 'lib/utils/copyToClipboard'
-import { useState } from 'react'
-import { Setup2FA } from 'scenes/authentication/Setup2FA'
-import { setup2FALogic } from 'scenes/authentication/setup2FALogic'
-import { membersLogic } from 'scenes/organization/membersLogic'
-import { userLogic } from 'scenes/userLogic'
-
-export function TwoFactorAuthentication(): JSX.Element {
-    const { user } = useValues(userLogic)
-    const { updateUser } = useActions(userLogic)
-    const { loadMemberUpdates } = useActions(membersLogic)
-    const [setupModalVisible, setSetupModalVisible] = useState(false)
-    const [disableModalVisible, setDisableModalVisible] = useState(false)
-    const [backupCodesModalVisible, setBackupCodesModalVisible] = useState(false)
-    const { status } = useValues(setup2FALogic)
-    const { generateBackupCodes, disable2FA } = useActions(setup2FALogic)
-    const { featureFlags } = useValues(featureFlagLogic)
-
-    const handleSuccess = (): void => {
-        updateUser({})
-        loadMemberUpdates()
-    }
-
-    return (
-        <div className="flex flex-col items-start">
-            {setupModalVisible && (
-                <LemonModal title="Set up 2FA" onClose={() => setSetupModalVisible(false)}>
-                    <div className="max-w-xl">
-                        <b>
-                            Use an authenticator app like Google Authenticator or 1Password to scan the QR code below.
-                        </b>
-                        <Setup2FA
-                            onSuccess={() => {
-                                setSetupModalVisible(false)
-                                handleSuccess()
-                            }}
-                        />
-                    </div>
-                </LemonModal>
-            )}
-
-            {disableModalVisible && (
-                <LemonModal
-                    title="Disable 2FA"
-                    onClose={() => setDisableModalVisible(false)}
-                    footer={
-                        <>
-                            <LemonButton onClick={() => setDisableModalVisible(false)}>Cancel</LemonButton>
-                            <LemonButton
-                                type="primary"
-                                status="danger"
-                                onClick={() => {
-                                    disable2FA()
-                                    setDisableModalVisible(false)
-                                    handleSuccess()
-                                }}
-                            >
-                                Disable 2FA
-                            </LemonButton>
-                        </>
-                    }
-                >
-                    <p>
-                        Are you sure you want to disable two-factor authentication? This will make your account less
-                        secure.
-                    </p>
-                </LemonModal>
-            )}
-
-            {backupCodesModalVisible && (
-                <LemonModal title="Backup Codes" onClose={() => setBackupCodesModalVisible(false)}>
-                    <div className="space-y-4 max-w-md">
-                        <p>
-                            Save these backup codes in a secure location. Each code can only be used once to sign in if
-                            you lose access to your authentication device.
-                        </p>
-                        {status?.backup_codes?.length ? (
-                            <div className="bg-bg-3000 p-4 rounded font-mono space-y-1 relative">
-                                <LemonButton
-                                    icon={<IconCopy />}
-                                    size="small"
-                                    className="absolute top-4 right-4"
-                                    onClick={() => {
-                                        void copyToClipboard(status.backup_codes.join('\n') || '', 'backup codes')
-                                    }}
-                                >
-                                    Copy
-                                </LemonButton>
-                                {status.backup_codes.map((code) => (
-                                    <div key={code}>{code}</div>
-                                ))}
-                            </div>
-                        ) : (
-                            <div className="text-center">
-                                <p className="text-muted mb-2">No backup codes available</p>
-                            </div>
-                        )}
-                        <LemonButton
-                            type="primary"
-                            onClick={() => {
-                                generateBackupCodes()
-                            }}
-                        >
-                            {status?.backup_codes?.length ? 'Generate New Codes' : 'Generate Backup Codes'}
-                        </LemonButton>
-                    </div>
-                </LemonModal>
-            )}
-
-            {user?.is_2fa_enabled ? (
-                <>
-                    <div className="mb-2 flex items-center">
-                        <IconCheckCircle color="green" className="text-xl mr-2" />
-                        <span className="font-medium">2FA enabled</span>
-                    </div>
-                    {featureFlags[FEATURE_FLAGS.TWO_FACTOR_UI] ? (
-                        <div className="space-x-2 flex items-center">
-                            <LemonButton type="secondary" onClick={() => setBackupCodesModalVisible(true)}>
-                                View Backup Codes
-                            </LemonButton>
-                            <LemonButton type="secondary" status="danger" onClick={() => setDisableModalVisible(true)}>
-                                Disable 2FA
-                            </LemonButton>
-                        </div>
-                    ) : (
-                        <LemonButton type="primary" to="/account/two_factor/" targetBlank>
-                            Manage or disable 2FA
-                        </LemonButton>
-                    )}
-                </>
-            ) : (
-                <div>
-                    <div className="mb-2 flex items-center">
-                        <IconWarning color="orange" className="text-xl mr-2" />
-                        <span className="font-medium">2FA is not enabled</span>
-                    </div>
-                    <LemonButton type="primary" onClick={() => setSetupModalVisible(true)}>
-                        Set up 2FA
-                    </LemonButton>
-                </div>
-            )}
-        </div>
-    )
-}
diff --git a/frontend/src/scenes/settings/user/TwoFactorSettings.tsx b/frontend/src/scenes/settings/user/TwoFactorSettings.tsx
new file mode 100644
index 0000000000000..dad73b097f5a9
--- /dev/null
+++ b/frontend/src/scenes/settings/user/TwoFactorSettings.tsx
@@ -0,0 +1,120 @@
+import { IconCheckCircle, IconCopy, IconWarning } from '@posthog/icons'
+import { LemonButton, LemonModal } from '@posthog/lemon-ui'
+import { useActions, useValues } from 'kea'
+import { copyToClipboard } from 'lib/utils/copyToClipboard'
+import { twoFactorLogic } from 'scenes/authentication/twoFactorLogic'
+import { membersLogic } from 'scenes/organization/membersLogic'
+import { userLogic } from 'scenes/userLogic'
+
+export function TwoFactorSettings(): JSX.Element {
+    const { user } = useValues(userLogic)
+    const { status, isDisable2FAModalOpen, isBackupCodesModalOpen } = useValues(twoFactorLogic)
+
+    const { updateUser } = useActions(userLogic)
+    const { loadMemberUpdates } = useActions(membersLogic)
+    const { generateBackupCodes, disable2FA, openTwoFactorSetupModal, toggleDisable2FAModal, toggleBackupCodesModal } =
+        useActions(twoFactorLogic)
+
+    const handleSuccess = (): void => {
+        updateUser({})
+        loadMemberUpdates()
+    }
+
+    return (
+        <div className="flex flex-col items-start">
+            {isDisable2FAModalOpen && (
+                <LemonModal
+                    title="Disable 2FA"
+                    onClose={() => toggleDisable2FAModal(false)}
+                    footer={
+                        <>
+                            <LemonButton onClick={() => toggleDisable2FAModal(false)}>Cancel</LemonButton>
+                            <LemonButton
+                                type="primary"
+                                status="danger"
+                                onClick={() => {
+                                    disable2FA()
+                                    toggleDisable2FAModal(false)
+                                    handleSuccess()
+                                }}
+                            >
+                                Disable 2FA
+                            </LemonButton>
+                        </>
+                    }
+                >
+                    <p>Are you sure you want to disable 2FA authentication? This will make your account less secure.</p>
+                </LemonModal>
+            )}
+
+            {isBackupCodesModalOpen && (
+                <LemonModal title="Backup Codes" onClose={() => toggleBackupCodesModal(false)}>
+                    <div className="space-y-4 max-w-md">
+                        {status?.backup_codes?.length ? (
+                            <>
+                                <p>
+                                    Save these backup codes in a secure location. Each code can only be used once to
+                                    sign in if you lose access to your authentication device.
+                                </p>
+                                <div className="bg-bg-3000 p-4 rounded font-mono space-y-1 relative">
+                                    <LemonButton
+                                        icon={<IconCopy />}
+                                        size="small"
+                                        className="absolute top-4 right-4"
+                                        onClick={() => {
+                                            void copyToClipboard(status.backup_codes.join('\n') || '', 'backup codes')
+                                        }}
+                                    >
+                                        Copy
+                                    </LemonButton>
+                                    {status.backup_codes.map((code) => (
+                                        <div key={code}>{code}</div>
+                                    ))}
+                                </div>
+                            </>
+                        ) : (
+                            <div className="bg-bg-3000 p-4 rounded font-mono space-y-1 relative">
+                                <p className="text-muted mb-0">No backup codes generated</p>
+                            </div>
+                        )}
+                        <LemonButton
+                            type="primary"
+                            onClick={() => {
+                                generateBackupCodes()
+                            }}
+                        >
+                            {status?.backup_codes?.length ? 'Generate new codes' : 'Generate backup codes'}
+                        </LemonButton>
+                    </div>
+                </LemonModal>
+            )}
+
+            {user?.is_2fa_enabled ? (
+                <>
+                    <div className="mb-4 flex items-center space-x-2">
+                        <IconCheckCircle color="green" className="text-xl" />
+                        <span className="font-medium">2FA enabled</span>
+                    </div>
+                    <div className="space-x-2 flex items-center">
+                        <LemonButton type="secondary" onClick={() => toggleBackupCodesModal(true)}>
+                            View backup codes
+                        </LemonButton>
+                        <LemonButton type="secondary" status="danger" onClick={() => toggleDisable2FAModal(true)}>
+                            Disable 2FA
+                        </LemonButton>
+                    </div>
+                </>
+            ) : (
+                <div>
+                    <div className="mb-4 flex items-center space-x-2">
+                        <IconWarning color="orange" className="text-xl" />
+                        <span className="font-medium">2FA is not enabled</span>
+                    </div>
+                    <LemonButton type="primary" onClick={() => openTwoFactorSetupModal()}>
+                        Set up 2FA
+                    </LemonButton>
+                </div>
+            )}
+        </div>
+    )
+}
diff --git a/frontend/src/scenes/surveys/SurveyEdit.tsx b/frontend/src/scenes/surveys/SurveyEdit.tsx
index 28a2b8d920521..b6bf810e73577 100644
--- a/frontend/src/scenes/surveys/SurveyEdit.tsx
+++ b/frontend/src/scenes/surveys/SurveyEdit.tsx
@@ -26,7 +26,7 @@ import { FEATURE_FLAGS } from 'lib/constants'
 import { dayjs } from 'lib/dayjs'
 import { IconCancel } from 'lib/lemon-ui/icons'
 import { LemonField } from 'lib/lemon-ui/LemonField'
-import { LemonRadio } from 'lib/lemon-ui/LemonRadio'
+import { LemonRadio, LemonRadioOption } from 'lib/lemon-ui/LemonRadio'
 import { Tooltip } from 'lib/lemon-ui/Tooltip'
 import { featureFlagLogic as enabledFeaturesLogic } from 'lib/logic/featureFlagLogic'
 import { formatDate } from 'lib/utils'
@@ -100,6 +100,27 @@ export default function SurveyEdit(): JSX.Element {
         ? undefined
         : 'Upgrade your plan to use an adaptive limit on survey responses'
 
+    const surveyLimitOptions: LemonRadioOption<'until_stopped' | 'until_limit' | 'until_adaptive_limit'>[] = [
+        {
+            value: 'until_stopped',
+            label: 'Keep collecting responses until the survey is stopped',
+            'data-attr': 'survey-collection-until-stopped',
+        },
+        {
+            value: 'until_limit',
+            label: 'Stop displaying the survey after reaching a certain number of completed surveys',
+            'data-attr': 'survey-collection-until-limit',
+        },
+    ]
+
+    if (featureFlags[FEATURE_FLAGS.SURVEYS_ADAPTIVE_LIMITS]) {
+        surveyLimitOptions.push({
+            value: 'until_adaptive_limit',
+            label: 'Collect a certain number of surveys per day, week or month',
+            'data-attr': 'survey-collection-until-adaptive-limit',
+            disabledReason: surveysAdaptiveLimitsDisabledReason,
+        } as unknown as LemonRadioOption<'until_stopped' | 'until_limit' | 'until_adaptive_limit'>)
+    }
     useMemo(() => {
         if (surveyUsesLimit) {
             setDataCollectionType('until_limit')
@@ -912,24 +933,7 @@ export default function SurveyEdit(): JSX.Element {
                                                     }
                                                     setDataCollectionType(newValue)
                                                 }}
-                                                options={[
-                                                    {
-                                                        value: 'until_stopped',
-                                                        label: 'Keep collecting responses until the survey is stopped',
-                                                        'data-attr': 'survey-collection-until-stopped',
-                                                    },
-                                                    {
-                                                        value: 'until_limit',
-                                                        label: 'Stop displaying the survey after reaching a certain number of completed surveys',
-                                                        'data-attr': 'survey-collection-until-limit',
-                                                    },
-                                                    {
-                                                        value: 'until_adaptive_limit',
-                                                        label: 'Collect a certain number of surveys per day, week or month',
-                                                        'data-attr': 'survey-collection-until-adaptive-limit',
-                                                        disabledReason: surveysAdaptiveLimitsDisabledReason,
-                                                    },
-                                                ]}
+                                                options={surveyLimitOptions}
                                             />
                                         </LemonField.Pure>
                                     </div>
diff --git a/frontend/src/scenes/surveys/Surveys.tsx b/frontend/src/scenes/surveys/Surveys.tsx
index 35cbd13688bf9..b129ff84d514d 100644
--- a/frontend/src/scenes/surveys/Surveys.tsx
+++ b/frontend/src/scenes/surveys/Surveys.tsx
@@ -18,6 +18,7 @@ import { MemberSelect } from 'lib/components/MemberSelect'
 import { PageHeader } from 'lib/components/PageHeader'
 import { ProductIntroduction } from 'lib/components/ProductIntroduction/ProductIntroduction'
 import { VersionCheckerBanner } from 'lib/components/VersionChecker/VersionCheckerBanner'
+import { FEATURE_FLAGS } from 'lib/constants'
 import { dayjs } from 'lib/dayjs'
 import { useFeatureFlag } from 'lib/hooks/useFeatureFlag'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
@@ -27,6 +28,7 @@ import { LemonTableColumn } from 'lib/lemon-ui/LemonTable'
 import { createdAtColumn, createdByColumn } from 'lib/lemon-ui/LemonTable/columnUtils'
 import { LemonTableLink } from 'lib/lemon-ui/LemonTable/LemonTableLink'
 import { LemonTabs } from 'lib/lemon-ui/LemonTabs'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import stringWithWBR from 'lib/utils/stringWithWBR'
 import { useState } from 'react'
 import { LinkedHogFunctions } from 'scenes/pipeline/hogfunctions/list/LinkedHogFunctions'
@@ -67,6 +69,8 @@ export function Surveys(): JSX.Element {
     const { user } = useValues(userLogic)
     const { updateCurrentTeam } = useActions(teamLogic)
     const { currentTeam } = useValues(teamLogic)
+    const { featureFlags } = useValues(featureFlagLogic)
+
     const [editableSurveyConfig, setEditableSurveyConfig] = useState(
         currentTeam?.survey_config?.appearance || defaultSurveyAppearance
     )
@@ -78,6 +82,7 @@ export function Surveys(): JSX.Element {
     }
     const shouldShowEmptyState = !surveysLoading && surveys.length === 0
     const showLinkedHogFunctions = useFeatureFlag('HOG_FUNCTIONS_LINKED')
+    const settingLevel = featureFlags[FEATURE_FLAGS.ENVIRONMENTS] ? 'environment' : 'project'
 
     return (
         <div>
@@ -224,8 +229,8 @@ export function Surveys(): JSX.Element {
                                 }}
                                 className="mb-2"
                             >
-                                Survey popovers are currently disabled for this project but there are active surveys
-                                running. Re-enable them in the settings.
+                                Survey popovers are currently disabled for this {settingLevel} but there are active
+                                surveys running. Re-enable them in the settings.
                             </LemonBanner>
                         ) : null}
                     </div>
diff --git a/frontend/src/scenes/surveys/utils.ts b/frontend/src/scenes/surveys/utils.ts
index 7ab39dc59c6e5..4493e1ac943e6 100644
--- a/frontend/src/scenes/surveys/utils.ts
+++ b/frontend/src/scenes/surveys/utils.ts
@@ -1,7 +1,7 @@
-import { sanitize } from 'dompurify'
+import DOMPurify from 'dompurify'
 
 const sanitizeConfig = { ADD_ATTR: ['target'] }
 
 export function sanitizeHTML(html: string): string {
-    return sanitize(html, sanitizeConfig)
+    return DOMPurify.sanitize(html, sanitizeConfig)
 }
diff --git a/frontend/src/scenes/teamActivityDescriber.tsx b/frontend/src/scenes/teamActivityDescriber.tsx
index bc08596af9a23..4bde2cf4d8e50 100644
--- a/frontend/src/scenes/teamActivityDescriber.tsx
+++ b/frontend/src/scenes/teamActivityDescriber.tsx
@@ -362,6 +362,7 @@ const teamActionsMapping: Record<
     id: () => null,
     updated_at: () => null,
     uuid: () => null,
+    user_access_level: () => null,
     live_events_token: () => null,
     product_intents: () => null,
 }
diff --git a/frontend/src/scenes/trends/mathsLogic.tsx b/frontend/src/scenes/trends/mathsLogic.tsx
index 04756fd135dd9..7f907d3f1f246 100644
--- a/frontend/src/scenes/trends/mathsLogic.tsx
+++ b/frontend/src/scenes/trends/mathsLogic.tsx
@@ -145,12 +145,29 @@ export const BASE_MATH_DEFINITIONS: Record<BaseMathType, MathDefinition> = {
         shortName: 'first time',
         description: (
             <>
-                Only count events if users do it for the first time.
+                Only the first time the user performed this event will count, and only if it matches the event filters.
                 <br />
                 <br />
                 <i>
-                    Example: If a single user performs an event for the first time ever within a given period, it counts
-                    as 1. Subsequent events by the same user will not be counted.
+                    Example: If the we are looking for pageview events to posthog.com/about, but the user's first
+                    pageview was on posthog.com, it will not match, even if they went to posthog.com/about afterwards.
+                </i>
+            </>
+        ),
+        category: MathCategory.EventCount,
+    },
+    [BaseMathType.FirstMatchingEventForUser]: {
+        name: 'First matching event for user',
+        shortName: 'first matching event',
+        description: (
+            <>
+                The first time the user performed this event that matches the event filters will count.
+                <br />
+                <br />
+                <i>
+                    Example: If the we are looking for pageview events to posthog.com/about, and the user's first
+                    pageview was on posthog.com but then they navigated to posthog.com/about, it will match the pageview
+                    event from posthog.com/about
                 </i>
             </>
         ),
diff --git a/frontend/src/scenes/trends/persons-modal/personsModalLogic.ts b/frontend/src/scenes/trends/persons-modal/personsModalLogic.ts
index 55514365774c9..76d53ecd6e66c 100644
--- a/frontend/src/scenes/trends/persons-modal/personsModalLogic.ts
+++ b/frontend/src/scenes/trends/persons-modal/personsModalLogic.ts
@@ -331,7 +331,7 @@ export const personsModalLogic = kea<personsModalLogicType>([
             () => [(_, p) => p.additionalSelect],
             (additionalSelect: PersonModalLogicProps['additionalSelect']): string[] => {
                 const extra = Object.values(additionalSelect || {})
-                return ['actor', 'created_at', ...extra]
+                return ['actor', ...extra]
             },
         ],
         actorsQuery: [
@@ -344,7 +344,7 @@ export const personsModalLogic = kea<personsModalLogicType>([
                     kind: NodeKind.ActorsQuery,
                     source: query,
                     select: selectFields,
-                    orderBy: orderBy || ['created_at DESC'],
+                    orderBy: orderBy || [],
                     search: searchTerm,
                 }
             },
diff --git a/frontend/src/scenes/urls.ts b/frontend/src/scenes/urls.ts
index bfcc75e8bd7e3..477064de6497e 100644
--- a/frontend/src/scenes/urls.ts
+++ b/frontend/src/scenes/urls.ts
@@ -159,6 +159,7 @@ export const urls = {
     experiments: (): string => '/experiments',
     featureFlags: (tab?: string): string => `/feature_flags${tab ? `?tab=${tab}` : ''}`,
     featureFlag: (id: string | number): string => `/feature_flags/${id}`,
+    featureManagement: (id?: string | number): string => `/features${id ? `/${id}` : ''}`,
     earlyAccessFeatures: (): string => '/early_access_features',
     /** @param id A UUID or 'new'. ':id' for routing. */
     earlyAccessFeature: (id: string): string => `/early_access_features/${id}`,
diff --git a/frontend/src/scenes/userLogic.ts b/frontend/src/scenes/userLogic.ts
index 9db1e96fa8806..a3adad1c6f50e 100644
--- a/frontend/src/scenes/userLogic.ts
+++ b/frontend/src/scenes/userLogic.ts
@@ -55,7 +55,7 @@ export const userLogic = kea<userLogicType>([
             {
                 loadUser: async () => {
                     try {
-                        return await api.get('api/users/@me/')
+                        return await api.get<UserType>('api/users/@me/')
                     } catch (error: any) {
                         console.error(error)
                         actions.loadUserFailure(error.message)
@@ -67,12 +67,13 @@ export const userLogic = kea<userLogicType>([
                         throw new Error('Current user has not been loaded yet, so it cannot be updated!')
                     }
                     try {
-                        const response = await api.update('api/users/@me/', user)
+                        const response = await api.update<UserType>('api/users/@me/', user)
                         successCallback && successCallback()
                         return response
                     } catch (error: any) {
                         console.error(error)
                         actions.updateUserFailure(error.message)
+                        return values.user
                     }
                 },
                 setUserScenePersonalisation: async ({ scene, dashboard }) => {
@@ -80,13 +81,14 @@ export const userLogic = kea<userLogicType>([
                         throw new Error('Current user has not been loaded yet, so it cannot be updated!')
                     }
                     try {
-                        return await api.create('api/users/@me/scene_personalisation', {
+                        return await api.create<UserType>('api/users/@me/scene_personalisation', {
                             scene,
                             dashboard,
                         })
                     } catch (error: any) {
                         console.error(error)
                         actions.updateUserFailure(error.message)
+                        return values.user
                     }
                 },
             },
diff --git a/frontend/src/scenes/web-analytics/WebAnalyticsHealthCheck.tsx b/frontend/src/scenes/web-analytics/WebAnalyticsHealthCheck.tsx
index b5374e075f9bf..51de3e725a13d 100644
--- a/frontend/src/scenes/web-analytics/WebAnalyticsHealthCheck.tsx
+++ b/frontend/src/scenes/web-analytics/WebAnalyticsHealthCheck.tsx
@@ -1,14 +1,12 @@
 import { useValues } from 'kea'
-import { useFeatureFlag } from 'lib/hooks/useFeatureFlag'
 import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
 import { Link } from 'lib/lemon-ui/Link'
 import { ConversionGoalWarning, webAnalyticsLogic } from 'scenes/web-analytics/webAnalyticsLogic'
 
 export const WebAnalyticsHealthCheck = (): JSX.Element | null => {
     const { statusCheck, conversionGoalWarning } = useValues(webAnalyticsLogic)
-    const isFlagConversionGoalWarningsSet = useFeatureFlag('WEB_ANALYTICS_WARN_CUSTOM_EVENT_NO_SESSION')
 
-    if (conversionGoalWarning && isFlagConversionGoalWarningsSet) {
+    if (conversionGoalWarning) {
         switch (conversionGoalWarning) {
             case ConversionGoalWarning.CustomEventWithNoSessionId:
                 return (
diff --git a/frontend/src/scenes/web-analytics/WebDashboard.tsx b/frontend/src/scenes/web-analytics/WebDashboard.tsx
index f1e4cd05bc99f..710577cfcf5f9 100644
--- a/frontend/src/scenes/web-analytics/WebDashboard.tsx
+++ b/frontend/src/scenes/web-analytics/WebDashboard.tsx
@@ -1,6 +1,7 @@
 import { IconExpand45, IconInfo, IconOpenSidebar, IconX } from '@posthog/icons'
 import clsx from 'clsx'
 import { BindLogic, useActions, useValues } from 'kea'
+import { CompareFilter } from 'lib/components/CompareFilter/CompareFilter'
 import { DateFilter } from 'lib/components/DateFilter/DateFilter'
 import { VersionCheckerBanner } from 'lib/components/VersionChecker/VersionCheckerBanner'
 import { FEATURE_FLAGS } from 'lib/constants'
@@ -38,10 +39,10 @@ const Filters = (): JSX.Element => {
     const {
         webAnalyticsFilters,
         dateFilter: { dateTo, dateFrom },
+        compareFilter,
     } = useValues(webAnalyticsLogic)
-    const { setWebAnalyticsFilters, setDates } = useActions(webAnalyticsLogic)
+    const { setWebAnalyticsFilters, setDates, setCompareFilter } = useActions(webAnalyticsLogic)
     const { mobileLayout } = useValues(navigationLogic)
-    const { conversionGoal } = useValues(webAnalyticsLogic)
     const { featureFlags } = useValues(featureFlagLogic)
 
     return (
@@ -53,13 +54,15 @@ const Filters = (): JSX.Element => {
         >
             <div className="flex flex-row flex-wrap gap-2">
                 <DateFilter dateFrom={dateFrom} dateTo={dateTo} onChange={setDates} />
+                {featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_PERIOD_COMPARISON] ? (
+                    <CompareFilter compareFilter={compareFilter} updateCompareFilter={setCompareFilter} />
+                ) : null}
+
                 <WebPropertyFilters
                     setWebAnalyticsFilters={setWebAnalyticsFilters}
                     webAnalyticsFilters={webAnalyticsFilters}
                 />
-                {featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_CONVERSION_GOALS] || conversionGoal ? (
-                    <WebConversionGoal />
-                ) : null}
+                <WebConversionGoal />
                 <ReloadAll />
             </div>
             <div className="bg-border h-px w-full mt-2" />
diff --git a/frontend/src/scenes/web-analytics/liveWebAnalyticsLogic.tsx b/frontend/src/scenes/web-analytics/liveWebAnalyticsLogic.tsx
index ef6b96398e775..66b628974045b 100644
--- a/frontend/src/scenes/web-analytics/liveWebAnalyticsLogic.tsx
+++ b/frontend/src/scenes/web-analytics/liveWebAnalyticsLogic.tsx
@@ -1,5 +1,4 @@
 import { actions, connect, events, kea, listeners, path, reducers, selectors } from 'kea'
-import { FEATURE_FLAGS } from 'lib/constants'
 import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { liveEventsHostOrigin } from 'lib/utils/apiHost'
 import { teamLogic } from 'scenes/teamLogic'
@@ -78,20 +77,18 @@ export const liveEventsTableLogic = kea<liveEventsTableLogicType>([
             }
         },
     })),
-    events(({ actions, cache, values }) => ({
+    events(({ actions, cache }) => ({
         afterMount: () => {
-            if (values.featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_LIVE_USER_COUNT]) {
-                actions.setNow({ now: new Date() })
-                actions.pollStats()
+            actions.setNow({ now: new Date() })
+            actions.pollStats()
 
-                cache.statsInterval = setInterval(() => {
-                    actions.pollStats()
-                }, 30000)
+            cache.statsInterval = setInterval(() => {
+                actions.pollStats()
+            }, 30000)
 
-                cache.nowInterval = setInterval(() => {
-                    actions.setNow({ now: new Date() })
-                }, 500)
-            }
+            cache.nowInterval = setInterval(() => {
+                actions.setNow({ now: new Date() })
+            }, 500)
         },
         beforeUnmount: () => {
             if (cache.statsInterval) {
diff --git a/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx b/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx
index ee32168dd7817..b04d7cdaa8953 100644
--- a/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx
+++ b/frontend/src/scenes/web-analytics/tiles/WebAnalyticsRecordings.tsx
@@ -16,6 +16,7 @@ export function WebAnalyticsRecordingsTile({ tile }: { tile: ReplayTile }): JSX.
     const { layout } = tile
     const { replayFilters, webAnalyticsFilters } = useValues(webAnalyticsLogic)
     const { currentTeam } = useValues(teamLogic)
+
     const sessionRecordingsListLogicInstance = sessionRecordingsPlaylistLogic({
         logicKey: 'webAnalytics',
         filters: replayFilters,
diff --git a/frontend/src/scenes/web-analytics/tiles/WebAnalyticsTile.tsx b/frontend/src/scenes/web-analytics/tiles/WebAnalyticsTile.tsx
index 63ef78e423bce..38ce8be4ef977 100644
--- a/frontend/src/scenes/web-analytics/tiles/WebAnalyticsTile.tsx
+++ b/frontend/src/scenes/web-analytics/tiles/WebAnalyticsTile.tsx
@@ -45,9 +45,11 @@ const VariationCell = (
     { isPercentage, reverseColors }: VariationCellProps = { isPercentage: false, reverseColors: false }
 ): QueryContextColumnComponent => {
     const formatNumber = (value: number): string =>
-        isPercentage ? `${(value * 100).toFixed(1)}%` : value.toLocaleString()
+        isPercentage ? `${(value * 100).toFixed(1)}%` : value?.toLocaleString() ?? '(empty)'
 
     return function Cell({ value }) {
+        const { compareFilter } = useValues(webAnalyticsLogic)
+
         if (!value) {
             return null
         }
@@ -57,10 +59,11 @@ const VariationCell = (
         }
 
         const [current, previous] = value as [number, number]
+
         const pctChangeFromPrevious =
             previous === 0 && current === 0 // Special case, render as flatline
                 ? 0
-                : current === null
+                : current === null || !compareFilter || compareFilter.compare === false
                 ? null
                 : previous === null || previous === 0
                 ? Infinity
@@ -321,6 +324,11 @@ export const webAnalyticsDataTableQueryContext: QueryContext = {
             render: VariationCell(),
             align: 'right',
         },
+        unique_conversions: {
+            title: <span className="pr-5">Unique Conversions</span>,
+            render: VariationCell(),
+            align: 'right',
+        },
         conversion_rate: {
             title: <span className="pr-5">Conversion Rate</span>,
             render: VariationCell({ isPercentage: true }),
diff --git a/frontend/src/scenes/web-analytics/webAnalyticsLogic.tsx b/frontend/src/scenes/web-analytics/webAnalyticsLogic.tsx
index d5d93400466d3..bd3f9afb4e78e 100644
--- a/frontend/src/scenes/web-analytics/webAnalyticsLogic.tsx
+++ b/frontend/src/scenes/web-analytics/webAnalyticsLogic.tsx
@@ -6,7 +6,7 @@ import api from 'lib/api'
 import { FEATURE_FLAGS, RETENTION_FIRST_TIME, STALE_EVENT_SECONDS } from 'lib/constants'
 import { dayjs } from 'lib/dayjs'
 import { Link, PostHogComDocsURL } from 'lib/lemon-ui/Link/Link'
-import { featureFlagLogic, FeatureFlagsSet } from 'lib/logic/featureFlagLogic'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { getDefaultInterval, isNotNil, objectsEqual, updateDatesWithInterval } from 'lib/utils'
 import { errorTrackingQuery } from 'scenes/error-tracking/queries'
 import { urls } from 'scenes/urls'
@@ -16,6 +16,7 @@ import {
     ActionConversionGoal,
     ActionsNode,
     AnyEntityNode,
+    CompareFilter,
     CustomEventConversionGoal,
     EventsNode,
     NodeKind,
@@ -44,6 +45,7 @@ import {
     PropertyOperator,
     RecordingUniversalFilters,
     RetentionPeriod,
+    UniversalFiltersGroupValue,
 } from '~/types'
 
 import type { webAnalyticsLogicType } from './webAnalyticsLogicType'
@@ -279,6 +281,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
             return { tileId, tabId }
         },
         setConversionGoalWarning: (warning: ConversionGoalWarning | null) => ({ warning }),
+        setCompareFilter: (compareFilter: CompareFilter) => ({ compareFilter }),
     }),
     reducers({
         webAnalyticsFilters: [
@@ -471,6 +474,13 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                 setConversionGoalWarning: (_, { warning }) => warning,
             },
         ],
+        compareFilter: [
+            { compare: true } as CompareFilter,
+            persistConfig,
+            {
+                setCompareFilter: (_, { compareFilter }) => compareFilter,
+            },
+        ],
     }),
     selectors(({ actions, values }) => ({
         graphsTab: [(s) => [s._graphsTab], (graphsTab: string | null) => graphsTab || GraphsTab.UNIQUE_USERS],
@@ -505,11 +515,12 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
             }),
         ],
         filters: [
-            (s) => [s.webAnalyticsFilters, s.replayFilters, s.dateFilter, () => values.conversionGoal],
-            (webAnalyticsFilters, replayFilters, dateFilter, conversionGoal) => ({
+            (s) => [s.webAnalyticsFilters, s.replayFilters, s.dateFilter, s.compareFilter, () => values.conversionGoal],
+            (webAnalyticsFilters, replayFilters, dateFilter, compareFilter, conversionGoal) => ({
                 webAnalyticsFilters,
                 replayFilters,
                 dateFilter,
+                compareFilter,
                 conversionGoal,
             }),
         ],
@@ -518,7 +529,13 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
             (
                 { graphsTab, sourceTab, deviceTab, pathTab, geographyTab, shouldShowGeographyTile },
                 { isPathCleaningEnabled, filterTestAccounts, shouldStripQueryParams },
-                { webAnalyticsFilters, replayFilters, dateFilter: { dateFrom, dateTo, interval }, conversionGoal },
+                {
+                    webAnalyticsFilters,
+                    replayFilters,
+                    dateFilter: { dateFrom, dateTo, interval },
+                    conversionGoal,
+                    compareFilter,
+                },
                 featureFlags,
                 isGreaterThanMd
             ): WebDashboardTile[] => {
@@ -526,7 +543,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                     date_from: dateFrom,
                     date_to: dateTo,
                 }
-                const compare = !!dateRange.date_from && dateRange.date_from !== 'all'
+
                 const sampling = {
                     enabled: false,
                     forceSamplingRate: { numerator: 1, denominator: 10 },
@@ -604,10 +621,11 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                 display: ChartDisplayType.ActionsLineGraph,
                                 ...trendsFilter,
                             },
-                            compareFilter: {
-                                compare,
-                            },
+                            compareFilter,
                             filterTestAccounts,
+                            conversionGoal: featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_CONVERSION_GOAL_FILTERS]
+                                ? conversionGoal
+                                : undefined,
                             properties: webAnalyticsFilters,
                         },
                         hidePersonsModal: true,
@@ -645,8 +663,12 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                 breakdownBy: breakdownBy,
                                 dateRange,
                                 sampling,
+                                compareFilter,
                                 limit: 10,
                                 filterTestAccounts,
+                                conversionGoal: featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_CONVERSION_GOAL_FILTERS]
+                                    ? conversionGoal
+                                    : undefined,
                                 ...(source || {}),
                             },
                             embedded: false,
@@ -671,10 +693,10 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                             properties: webAnalyticsFilters,
                             dateRange,
                             sampling,
-                            compare,
+                            compareFilter,
                             filterTestAccounts,
                             conversionGoal,
-                            includeLCPScore: featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_LCP_SCORE] ? true : undefined,
+                            includeLCPScore: true,
                         },
                         insightProps: createInsightProps(TileId.OVERVIEW),
                         canOpenModal: false,
@@ -768,14 +790,21 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                                         accessed in your application, regardless of when they were
                                                         accessed through the lifetime of a user session.
                                                     </p>
-                                                    <p>
-                                                        The{' '}
-                                                        <Link to="https://posthog.com/docs/web-analytics/dashboard#bounce-rate">
-                                                            bounce rate
-                                                        </Link>{' '}
-                                                        indicates the percentage of users who left your page immediately
-                                                        after visiting without capturing any event.
-                                                    </p>
+                                                    {conversionGoal ? (
+                                                        <p>
+                                                            The conversion rate is the percentage of users who completed
+                                                            the conversion goal in this specific path.
+                                                        </p>
+                                                    ) : (
+                                                        <p>
+                                                            The{' '}
+                                                            <Link to="https://posthog.com/docs/web-analytics/dashboard#bounce-rate">
+                                                                bounce rate
+                                                            </Link>{' '}
+                                                            indicates the percentage of users who left your page
+                                                            immediately after visiting without capturing any event.
+                                                        </p>
+                                                    )}
                                                 </div>
                                             ),
                                         },
@@ -799,8 +828,17 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                             title: 'Entry Path',
                                             description: (
                                                 <div>
-                                                    Entry paths are the paths a user session started, i.e. the first
-                                                    path they saw when they opened your website.
+                                                    <p>
+                                                        Entry paths are the paths a user session started, i.e. the first
+                                                        path they saw when they opened your website.
+                                                    </p>
+                                                    {conversionGoal && (
+                                                        <p>
+                                                            The conversion rate is the percentage of users who completed
+                                                            the conversion goal after the first path in their session
+                                                            being this path.
+                                                        </p>
+                                                    )}
                                                 </div>
                                             ),
                                         },
@@ -832,39 +870,43 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                         },
                                     }
                                 ),
-                                featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_LAST_CLICK]
-                                    ? {
-                                          id: PathTab.EXIT_CLICK,
-                                          title: 'Outbound link clicks',
-                                          linkText: 'Outbound clicks',
-                                          query: {
-                                              full: true,
-                                              kind: NodeKind.DataTableNode,
-                                              source: {
-                                                  kind: NodeKind.WebExternalClicksTableQuery,
-                                                  properties: webAnalyticsFilters,
-                                                  dateRange,
-                                                  sampling,
-                                                  limit: 10,
-                                                  filterTestAccounts,
-                                                  stripQueryParams: shouldStripQueryParams,
-                                              },
-                                              embedded: false,
-                                              columns: ['url', 'visitors', 'clicks'],
-                                          },
-                                          insightProps: createInsightProps(TileId.PATHS, PathTab.END_PATH),
-                                          canOpenModal: true,
-                                          docs: {
-                                              title: 'Outbound Clicks',
-                                              description: (
-                                                  <div>
-                                                      You'll be able to verify when someone leaves your website by
-                                                      clicking an outbound link (to a separate domain)
-                                                  </div>
-                                              ),
-                                          },
-                                      }
-                                    : null,
+                                {
+                                    id: PathTab.EXIT_CLICK,
+                                    title: 'Outbound link clicks',
+                                    linkText: 'Outbound clicks',
+                                    query: {
+                                        full: true,
+                                        kind: NodeKind.DataTableNode,
+                                        source: {
+                                            kind: NodeKind.WebExternalClicksTableQuery,
+                                            properties: webAnalyticsFilters,
+                                            dateRange,
+                                            compareFilter,
+                                            sampling,
+                                            limit: 10,
+                                            filterTestAccounts,
+                                            conversionGoal: featureFlags[
+                                                FEATURE_FLAGS.WEB_ANALYTICS_CONVERSION_GOAL_FILTERS
+                                            ]
+                                                ? conversionGoal
+                                                : undefined,
+                                            stripQueryParams: shouldStripQueryParams,
+                                        },
+                                        embedded: false,
+                                        columns: ['url', 'visitors', 'clicks'],
+                                    },
+                                    insightProps: createInsightProps(TileId.PATHS, PathTab.END_PATH),
+                                    canOpenModal: true,
+                                    docs: {
+                                        title: 'Outbound Clicks',
+                                        description: (
+                                            <div>
+                                                You'll be able to verify when someone leaves your website by clicking an
+                                                outbound link (to a separate domain)
+                                            </div>
+                                        ),
+                                    },
+                                },
                             ] as (TabsTileTab | undefined)[]
                         ).filter(isNotNil),
                     },
@@ -895,21 +937,15 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                                     Channels are the different sources that bring traffic to your
                                                     website, e.g. Paid Search, Organic Social, Direct, etc.
                                                 </p>
-                                                {featureFlags[FEATURE_FLAGS.CUSTOM_CHANNEL_TYPE_RULES] && (
-                                                    <p>
-                                                        You can also{' '}
-                                                        <Link
-                                                            to={urls.settings(
-                                                                'environment-web-analytics',
-                                                                'channel-type'
-                                                            )}
-                                                        >
-                                                            create custom channel types
-                                                        </Link>
-                                                        , allowing you to further categorize your channels.
-                                                    </p>
-                                                )}
-
+                                                <p>
+                                                    You can also{' '}
+                                                    <Link
+                                                        to={urls.settings('environment-web-analytics', 'channel-type')}
+                                                    >
+                                                        create custom channel types
+                                                    </Link>
+                                                    , allowing you to further categorize your channels.
+                                                </p>
                                                 <p>
                                                     Something unexpected? Try the{' '}
                                                     <Link to={urls.sessionAttributionExplorer()}>
@@ -1121,6 +1157,11 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                               trendsFilter: {
                                                   display: ChartDisplayType.WorldMap,
                                               },
+                                              conversionGoal: featureFlags[
+                                                  FEATURE_FLAGS.WEB_ANALYTICS_CONVERSION_GOAL_FILTERS
+                                              ]
+                                                  ? conversionGoal
+                                                  : undefined,
                                               filterTestAccounts,
                                               properties: webAnalyticsFilters,
                                           },
@@ -1168,63 +1209,66 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                               ],
                           }
                         : null,
-                    {
-                        kind: 'query',
-                        tileId: TileId.RETENTION,
-                        title: 'Retention',
-                        layout: {
-                            colSpanClassName: 'md:col-span-2',
-                        },
-                        query: {
-                            kind: NodeKind.InsightVizNode,
-                            source: {
-                                kind: NodeKind.RetentionQuery,
-                                properties: webAnalyticsFilters,
-                                dateRange,
-                                filterTestAccounts,
-                                retentionFilter: {
-                                    retentionType: RETENTION_FIRST_TIME,
-                                    retentionReference: 'total',
-                                    totalIntervals: isGreaterThanMd ? 8 : 5,
-                                    period: RetentionPeriod.Week,
-                                },
-                            },
-                            vizSpecificOptions: {
-                                [InsightType.RETENTION]: {
-                                    hideLineGraph: true,
-                                    hideSizeColumn: !isGreaterThanMd,
-                                    useSmallLayout: !isGreaterThanMd,
-                                },
-                            },
-                            embedded: true,
-                        },
-                        insightProps: createInsightProps(TileId.RETENTION),
-                        canOpenInsight: false,
-                        canOpenModal: true,
-                        docs: {
-                            url: 'https://posthog.com/docs/web-analytics/dashboard#retention',
-                            title: 'Retention',
-                            description: (
-                                <>
-                                    <div>
-                                        <p>
-                                            Retention creates a cohort of unique users who performed any event for the
-                                            first time in the last week. It then tracks the percentage of users who
-                                            return to perform any event in the following weeks.
-                                        </p>
-                                        <p>
-                                            You want the numbers numbers to be the highest possible, suggesting that
-                                            people that come to your page continue coming to your page - and performing
-                                            an actions. Also, the further down the table the higher the numbers should
-                                            be (or at least as high), which would indicate that you're either increasing
-                                            or keeping your retention at the same level.
-                                        </p>
-                                    </div>
-                                </>
-                            ),
-                        },
-                    },
-                    featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_CONVERSION_GOALS]
+                    !conversionGoal
+                        ? {
+                              kind: 'query',
+                              tileId: TileId.RETENTION,
+                              title: 'Retention',
+                              layout: {
+                                  colSpanClassName: 'md:col-span-2',
+                              },
+                              query: {
+                                  kind: NodeKind.InsightVizNode,
+                                  source: {
+                                      kind: NodeKind.RetentionQuery,
+                                      properties: webAnalyticsFilters,
+                                      dateRange,
+                                      filterTestAccounts,
+                                      retentionFilter: {
+                                          retentionType: RETENTION_FIRST_TIME,
+                                          retentionReference: 'total',
+                                          totalIntervals: isGreaterThanMd ? 8 : 5,
+                                          period: RetentionPeriod.Week,
+                                      },
+                                  },
+                                  vizSpecificOptions: {
+                                      [InsightType.RETENTION]: {
+                                          hideLineGraph: true,
+                                          hideSizeColumn: !isGreaterThanMd,
+                                          useSmallLayout: !isGreaterThanMd,
+                                      },
+                                  },
+                                  embedded: true,
+                              },
+                              insightProps: createInsightProps(TileId.RETENTION),
+                              canOpenInsight: false,
+                              canOpenModal: true,
+                              docs: {
+                                  url: 'https://posthog.com/docs/web-analytics/dashboard#retention',
+                                  title: 'Retention',
+                                  description: (
+                                      <>
+                                          <div>
+                                              <p>
+                                                  Retention creates a cohort of unique users who performed any event for
+                                                  the first time in the last week. It then tracks the percentage of
+                                                  users who return to perform any event in the following weeks.
+                                              </p>
+                                              <p>
+                                                  You want the numbers numbers to be the highest possible, suggesting
+                                                  that people that come to your page continue coming to your page - and
+                                                  performing an actions. Also, the further down the table the higher the
+                                                  numbers should be (or at least as high), which would indicate that
+                                                  you're either increasing or keeping your retention at the same level.
+                                              </p>
+                                          </div>
+                                      </>
+                                  ),
+                              },
+                          }
+                        : null,
+                    // Hiding if conversionGoal is set already because values aren't representative
+                    !conversionGoal
                         ? {
                               kind: 'query',
                               tileId: TileId.GOALS,
@@ -1239,6 +1283,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                                       kind: NodeKind.WebGoalsQuery,
                                       properties: webAnalyticsFilters,
                                       dateRange,
+                                      compareFilter,
                                       sampling,
                                       limit: 10,
                                       filterTestAccounts,
@@ -1270,12 +1315,12 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                               },
                           }
                         : null,
-                    featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_REPLAY]
+                    !conversionGoal
                         ? {
                               kind: 'replay',
                               tileId: TileId.REPLAY,
                               layout: {
-                                  colSpanClassName: 'md:col-span-1',
+                                  colSpanClassName: conversionGoal ? 'md:col-span-full' : 'md:col-span-1',
                               },
                               docs: {
                                   url: 'https://posthog.com/docs/session-replay',
@@ -1285,7 +1330,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                               },
                           }
                         : null,
-                    featureFlags[FEATURE_FLAGS.ERROR_TRACKING]
+                    !conversionGoal && featureFlags[FEATURE_FLAGS.ERROR_TRACKING]
                         ? {
                               kind: 'error_tracking',
                               tileId: TileId.ERROR_TRACKING,
@@ -1418,12 +1463,31 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
             },
         ],
         replayFilters: [
-            (s) => [s.webAnalyticsFilters, s.dateFilter, s.shouldFilterTestAccounts],
+            (s) => [s.webAnalyticsFilters, s.dateFilter, s.shouldFilterTestAccounts, s.conversionGoal, s.featureFlags],
             (
                 webAnalyticsFilters: WebAnalyticsPropertyFilters,
                 dateFilter,
-                shouldFilterTestAccounts
+                shouldFilterTestAccounts,
+                conversionGoal,
+                featureFlags
             ): RecordingUniversalFilters => {
+                const filters: UniversalFiltersGroupValue[] = [...webAnalyticsFilters]
+                if (conversionGoal && featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_CONVERSION_GOAL_FILTERS]) {
+                    if ('actionId' in conversionGoal) {
+                        filters.push({
+                            id: conversionGoal.actionId,
+                            name: String(conversionGoal.actionId),
+                            type: 'actions',
+                        })
+                    } else if ('customEventName' in conversionGoal) {
+                        filters.push({
+                            id: conversionGoal.customEventName,
+                            name: conversionGoal.customEventName,
+                            type: 'events',
+                        })
+                    }
+                }
+
                 return {
                     filter_test_accounts: shouldFilterTestAccounts,
 
@@ -1434,7 +1498,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                         values: [
                             {
                                 type: FilterLogicalOperator.And,
-                                values: webAnalyticsFilters || [],
+                                values: filters,
                             },
                         ],
                     },
@@ -1591,6 +1655,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                 _graphsTab,
                 isPathCleaningEnabled,
                 shouldFilterTestAccounts,
+                compareFilter,
             } = values
 
             const urlParams = new URLSearchParams()
@@ -1630,6 +1695,9 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
             if (shouldFilterTestAccounts != null) {
                 urlParams.set('filter_test_accounts', shouldFilterTestAccounts.toString())
             }
+            if (compareFilter) {
+                urlParams.set('compare_filter', JSON.stringify(compareFilter))
+            }
             return `/web?${urlParams.toString()}`
         }
 
@@ -1644,6 +1712,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
             setGraphsTab: stateToUrl,
             setPathTab: stateToUrl,
             setGeographyTab: stateToUrl,
+            setCompareFilter: stateToUrl,
         }
     }),
 
@@ -1664,6 +1733,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                 geography_tab,
                 path_cleaning,
                 filter_test_accounts,
+                compare_filter,
             }
         ) => {
             const parsedFilters = isWebAnalyticsPropertyFilters(filters) ? filters : undefined
@@ -1710,6 +1780,9 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
             if (filter_test_accounts && filter_test_accounts !== values.shouldFilterTestAccounts) {
                 actions.setShouldFilterTestAccounts([true, 'true', 1, '1'].includes(filter_test_accounts))
             }
+            if (compare_filter && !objectsEqual(compare_filter, values.compareFilter)) {
+                actions.setCompareFilter(compare_filter)
+            }
         },
     })),
     listeners(({ values, actions }) => {
@@ -1744,8 +1817,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
                     checkCustomEventConversionGoalHasSessionIdsHelper(
                         conversionGoal,
                         breakpoint,
-                        actions.setConversionGoalWarning,
-                        values.featureFlags
+                        actions.setConversionGoalWarning
                     ),
             ],
         }
@@ -1754,8 +1826,7 @@ export const webAnalyticsLogic = kea<webAnalyticsLogicType>([
         checkCustomEventConversionGoalHasSessionIdsHelper(
             values.conversionGoal,
             undefined,
-            actions.setConversionGoalWarning,
-            values.featureFlags
+            actions.setConversionGoalWarning
         ).catch(() => {
             // ignore, this warning is just a nice-to-have, no point showing an error to the user
         })
@@ -1770,13 +1841,8 @@ const isDefinitionStale = (definition: EventDefinition | PropertyDefinition): bo
 const checkCustomEventConversionGoalHasSessionIdsHelper = async (
     conversionGoal: WebAnalyticsConversionGoal | null,
     breakpoint: BreakPointFunction | undefined,
-    setConversionGoalWarning: (warning: ConversionGoalWarning | null) => void,
-    featureFlags: FeatureFlagsSet
+    setConversionGoalWarning: (warning: ConversionGoalWarning | null) => void
 ): Promise<void> => {
-    if (!featureFlags[FEATURE_FLAGS.WEB_ANALYTICS_WARN_CUSTOM_EVENT_NO_SESSION]) {
-        return
-    }
-
     if (!conversionGoal || !('customEventName' in conversionGoal) || !conversionGoal.customEventName) {
         setConversionGoalWarning(null)
         return
diff --git a/frontend/src/styles/global.scss b/frontend/src/styles/global.scss
index 59ed48b6988fb..0114e54cf72c2 100644
--- a/frontend/src/styles/global.scss
+++ b/frontend/src/styles/global.scss
@@ -19,6 +19,232 @@ Only 400 (`normal`), 500 (`var(--font-medium)`), 600 (`var(--font-semibold)`), o
 @import 'utilities-legacy'; // TODO: Remove all legacy utilities
 
 :root {
+    // Posthog 3030:
+    // https://www.figma.com/design/rQ5SvWb4P2AGt7o9KbKV21/Posthog-3030?node-id=79-2694&node-type=canvas&t=gY0DiwE0seyXYOL3-0
+    // Primitives colors
+    // DO NOT USE PRIMITIVE COLORS DIRECTLY.
+    // Use the semantic colors instead.
+    --primary-black: #000;
+    --primary-black-50: #00000080;
+    --primary-white: #fff;
+    --primary-white-50: #ffffff80;
+
+    // Neutral colors
+    --neutral-50: #fafafa;
+    --neutral-100: #f5f5f5;
+    --neutral-150: #ebebeb;
+    --neutral-200: #e0e0e0;
+    --neutral-250: #d6d6d6;
+    --neutral-300: #ccc;
+    --neutral-350: #bfbfbf;
+    --neutral-400: #b3b3b3;
+    --neutral-450: #a6a6a6;
+    --neutral-500: #999;
+    --neutral-550: #8c8c8c;
+    --neutral-600: #808080;
+    --neutral-650: #737373;
+    --neutral-700: #666;
+    --neutral-750: #595959;
+    --neutral-800: #4d4d4d;
+    --neutral-850: #404040;
+    --neutral-900: #333;
+    --neutral-950: #262626;
+
+    // Neutral warm colors (light mode backgrounds)
+    --neutral-warm-50: #f3f4f0;
+    --neutral-warm-100: #e8eae0;
+    --neutral-warm-150: #dde0d2;
+    --neutral-warm-200: #d2d6c2;
+    --neutral-warm-250: #c6cbb3;
+    --neutral-warm-300: #bbc1a3;
+    --neutral-warm-350: #b0b795;
+    --neutral-warm-400: #a5ac86;
+    --neutral-warm-450: #99a276;
+    --neutral-warm-500: #8e9867;
+    --neutral-warm-550: #80895d;
+    --neutral-warm-600: #727953;
+    --neutral-warm-650: #636a48;
+    --neutral-warm-700: #565c3e;
+    --neutral-warm-750: #474c34;
+    --neutral-warm-800: #393d29;
+    --neutral-warm-850: #2a2d1f;
+    --neutral-warm-900: #1d1f15;
+    --neutral-warm-950: #0e0f0b;
+
+    // Neutral cool colors (dark mode backgrounds)
+    --neutral-cool-50: #f1f2f3;
+    --neutral-cool-100: #e3e5e8;
+    --neutral-cool-150: #d6d8dc;
+    --neutral-cool-200: #c8cbd0;
+    --neutral-cool-250: #babec4;
+    --neutral-cool-300: #adb2b9;
+    --neutral-cool-350: #9fa5ad;
+    --neutral-cool-400: #9197a1;
+    --neutral-cool-450: #838a95;
+    --neutral-cool-500: #767e8a;
+    --neutral-cool-550: #6a717c;
+    --neutral-cool-600: #5e646e;
+    --neutral-cool-650: #525860;
+    --neutral-cool-700: #474c53;
+    --neutral-cool-750: #3b3f45;
+    --neutral-cool-800: #2f3237;
+    --neutral-cool-850: #232529;
+    --neutral-cool-900: #1b1c18;
+    --neutral-cool-950: #0e0e0c;
+
+    // Brand colors
+    --brand-100: #fddccc;
+    --brand-200: #fbb899;
+    --brand-300: #f99567;
+    --brand-400: #f77134;
+    --brand-500: #f54e01;
+    --brand-600: #c43e01;
+    --brand-700: #932f01;
+    --brand-800: #621f00;
+    --brand-900: #311000;
+
+    // Blue colors
+    --blue-100: #d2dcfd;
+    --blue-200: #a5b9fb;
+    --blue-300: #7995fa;
+    --blue-400: #4c72f8;
+    --blue-500: #1f4ff6;
+    --blue-600: #193fc5;
+    --blue-700: #132f94;
+    --blue-800: #0c2062;
+    --blue-900: #061031;
+
+    // Purple colors
+    --purple-100: #e0ceff;
+    --purple-200: #c29cff;
+    --purple-300: #a36bff;
+    --purple-400: #8539ff;
+    --purple-500: #6608ff;
+    --purple-600: #5206cc;
+    --purple-700: #3d0599;
+    --purple-800: #290366;
+    --purple-900: #140233;
+
+    // Violet colors
+    --violet-100: #f1d6ff;
+    --violet-200: #e4adff;
+    --violet-300: #d685ff;
+    --violet-400: #c95cff;
+    --violet-500: #b3f;
+    --violet-600: #9629cc;
+    --violet-700: #701f99;
+    --violet-800: #4b1466;
+    --violet-900: #250a33;
+
+    // Red colors
+    --red-50: #f9ebe6;
+    --red-100: #f8d7cd;
+    --red-200: #f1af9c;
+    --red-300: #e9876a;
+    --red-400: #e25f39;
+    --red-500: #db3707;
+    --red-600: #af2c06;
+    --red-700: #832104;
+    --red-800: #581603;
+    --red-900: #2c0b01;
+
+    // Orange colors
+    --orange-50: #fff3e5;
+    --orange-100: #ffe6cc;
+    --orange-200: #fc9;
+    --orange-300: #ffb366;
+    --orange-400: #f93;
+    --orange-500: #ff8000;
+    --orange-600: #c60;
+    --orange-700: #994d00;
+    --orange-800: #630;
+    --orange-850: #4c3201;
+    --orange-900: #331a00;
+
+    // Yellow colors
+    --yellow-100: #fdedcd;
+    --yellow-200: #fcdb9a;
+    --yellow-300: #fac968;
+    --yellow-400: #f9b735;
+    --yellow-500: #f7a503;
+    --yellow-600: #c68402;
+    --yellow-700: #946302;
+    --yellow-800: #634201;
+    --yellow-900: #312101;
+
+    // Green colors
+    --green-50: #ebf3e5;
+    --green-100: #d7e7cc;
+    --green-200: #afcf99;
+    --green-300: #88b666;
+    --green-400: #609e33;
+    --green-500: #388600;
+    --green-600: #2d6b00;
+    --green-700: #225000;
+    --green-800: #163600;
+    --green-900: #0b1b00;
+
+    // Teal colors
+    --teal-100: #d9f5f3;
+    --teal-200: #b3eae7;
+    --teal-300: #8de0dc;
+    --teal-400: #67d5d0;
+    --teal-500: #41cbc4;
+    --teal-600: #34a29d;
+    --teal-700: #277a76;
+    --teal-800: #1a514e;
+    --teal-900: #0d2927;
+
+    // Semantic colors
+    --content-primary: var(--neutral-950);
+    --content-secondary: var(--neutral-800);
+    --content-tertiary: var(--neutral-700);
+    --content-primary-inverse: var(--primary-white);
+    --content-secondary-inverse: var(--neutral-100);
+    --content-tertiary-inverse: var(--neutral-300);
+    --content-disabled: var(--neutral-300);
+    --content-brand: var(--brand-500);
+    --content-link: var(--brand-500);
+    --content-link-hover: var(--brand-400);
+    --content-link-pressed: var(--brand-600);
+    --content-warning: var(--orange-400);
+    --content-warning-bold: var(--orange-700);
+    --content-danger: var(--red-500);
+    --content-danger-bold: var(--red-600);
+    --content-danger-bold-disabled: var(--red-800);
+    --content-success: var(--green-500);
+    --content-success-bold: var(--green-600);
+    --content-success-bold-disabled: var(--green-700);
+    --background-primary: var(--primary-white);
+    --background-secondary: var(--neutral-warm-50);
+    --background-tertiary: var(--neutral-warm-100);
+    --background-hover: var(--neutral-warm-50);
+    --background-pressed: var(--neutral-warm-100);
+    --background-selected: var(--orange-100);
+    --background-disabled: var(--neutral-warm-50);
+    --background-inverse: var(--neutral-warm-900);
+    --background-brand: var(--brand-500);
+    --background-brand-hover: var(--brand-600);
+    --background-brand-pressed: var(--brand-700);
+    --background-warning: var(--orange-500);
+    --background-warning-subtle: var(--orange-50);
+    --background-danger: var(--red-500);
+    --background-danger-subtle: var(--red-50);
+    --background-success: var(--green-500);
+    --background-success-subtle: var(--green-50);
+    --border-primary: var(--neutral-warm-600);
+    --border-secondary: var(--neutral-warm-400);
+    --border-tertiary: var(--neutral-warm-200);
+    --border-disabled: var(--neutral-warm-200);
+    --border-brand: var(--brand-500);
+    --border-inverse: var(--primary-white);
+    --border-focus: var(--blue-500);
+    --border-warning: var(--orange-500);
+    --border-danger: var(--red-500);
+    --border-success: var(--green-500);
+    --overlay-50: var(--primary-black-50);
+    --overlay-50-inverse: var(--primary-white-50);
+
     @include root-variables;
 }
 
@@ -350,6 +576,20 @@ body {
     }
 
     &[theme='dark'] {
+        // Semantic colors (Dark mode) WIP
+        --content-primary: var(--neutral-cool-100);
+        --content-warning: var(--orange-300);
+        --content-warning-bold: var(--orange-100);
+        --content-danger-bold: var(--red-100);
+        --content-success-bold: var(--green-100);
+        --background-primary: var(--neutral-cool-900);
+        --background-secondary: var(--neutral-cool-850);
+        --background-tertiary: var(--neutral-cool-800);
+        --background-warning-subtle: var(--orange-850);
+        --background-danger-subtle: var(--red-800);
+        --background-success-subtle: var(--green-800);
+        --border-tertiary: var(--neutral-cool-750);
+
         @include dark-mode-3000-variables;
     }
 
diff --git a/frontend/src/styles/vars.scss b/frontend/src/styles/vars.scss
index 5ca521739a7d8..d42290fce8891 100644
--- a/frontend/src/styles/vars.scss
+++ b/frontend/src/styles/vars.scss
@@ -136,6 +136,174 @@ $_lifecycle_dormant: map.get($colors, 'danger');
 // root variables are defined as a mixin here because
 // the toolbar needs them attached to :host not :root
 @mixin root-variables {
+    // Posthog 3030:
+    // https://www.figma.com/design/rQ5SvWb4P2AGt7o9KbKV21/Posthog-3030?node-id=79-2694&node-type=canvas&t=gY0DiwE0seyXYOL3-0
+    // Primitives colors
+    // DO NOT USE PRIMITIVE COLORS DIRECTLY.
+    // Use the semantic colors instead.
+    --blue-100: #d2dcfd;
+    --blue-200: #a5b9fb;
+    --blue-300: #7995fa;
+    --blue-400: #4c72f8;
+    --blue-500: #1f4ff6;
+    --blue-600: #193fc5;
+    --blue-700: #132f94;
+    --blue-800: #0c2062;
+    --blue-900: #061031;
+    --brand-100: #fddccc;
+    --brand-200: #fbb899;
+    --brand-300: #f99567;
+    --brand-400: #f77134;
+    --brand-500: #f54e01;
+    --brand-600: #c43e01;
+    --brand-700: #932f01;
+    --brand-800: #621f00;
+    --brand-900: #311000;
+    --green-50: #ebf3e5;
+    --green-100: #d7e7cc;
+    --green-200: #afcf99;
+    --green-300: #88b666;
+    --green-400: #609e33;
+    --green-500: #388600;
+    --green-600: #2d6b00;
+    --green-700: #225000;
+    --green-800: #163600;
+    --green-900: #0b1b00;
+    --neutral-100: #e5e5e5;
+    --neutral-150: #d9d9d9;
+    --neutral-200: #ccc;
+    --neutral-250: #bfbfbf;
+    --neutral-300: #b2b2b2;
+    --neutral-350: #a6a6a6;
+    --neutral-400: #999;
+    --neutral-450: #8c8c8c;
+    --neutral-50: #f2f2f2;
+    --neutral-500: #808080;
+    --neutral-550: #737373;
+    --neutral-600: #666;
+    --neutral-650: #595959;
+    --neutral-700: #4d4d4d;
+    --neutral-750: #404040;
+    --neutral-800: #333;
+    --neutral-850: #262626;
+    --neutral-900: #1a1a1a;
+    --neutral-950: #0d0d0d;
+    --orange-50: #fff3e5;
+    --orange-100: #ffe6cc;
+    --orange-200: #fc9;
+    --orange-300: #ffb366;
+    --orange-400: #f93;
+    --orange-500: #ff8000;
+    --orange-600: #c60;
+    --orange-700: #994d00;
+    --orange-800: #630;
+    --orange-900: #331a00;
+    --pink-100: #ffedeb;
+    --pink-200: #ffdbd6;
+    --pink-300: #ffc9c2;
+    --pink-400: #ffb7ad;
+    --pink-500: #ffa599;
+    --pink-600: #cc847a;
+    --pink-700: #99635c;
+    --pink-800: #66423d;
+    --pink-900: #33211f;
+    --primary-black: #000;
+    --primary-black-50: #00000080;
+    --primary-white: #fff;
+    --primary-white-50: #ffffff80;
+    --purple-100: #e0ceff;
+    --purple-200: #c29cff;
+    --purple-300: #a36bff;
+    --purple-400: #8539ff;
+    --purple-500: #6608ff;
+    --purple-600: #5206cc;
+    --purple-700: #3d0599;
+    --purple-800: #290366;
+    --purple-900: #140233;
+    --red-50: #f9ebe6;
+    --red-100: #f8d7cd;
+    --red-200: #f1af9c;
+    --red-300: #e9876a;
+    --red-400: #e25f39;
+    --red-500: #db3707;
+    --red-600: #af2c06;
+    --red-700: #832104;
+    --red-800: #581603;
+    --red-900: #2c0b01;
+    --teal-100: #d9f5f3;
+    --teal-200: #b3eae7;
+    --teal-300: #8de0dc;
+    --teal-400: #67d5d0;
+    --teal-500: #41cbc4;
+    --teal-600: #34a29d;
+    --teal-700: #277a76;
+    --teal-800: #1a514e;
+    --teal-900: #0d2927;
+    --violet-100: #f1d6ff;
+    --violet-200: #e4adff;
+    --violet-300: #d685ff;
+    --violet-400: #c95cff;
+    --violet-500: #b3f;
+    --violet-600: #9629cc;
+    --violet-700: #701f99;
+    --violet-800: #4b1466;
+    --violet-900: #250a33;
+    --yellow-100: #fdedcd;
+    --yellow-200: #fcdb9a;
+    --yellow-300: #fac968;
+    --yellow-400: #f9b735;
+    --yellow-500: #f7a503;
+    --yellow-600: #c68402;
+    --yellow-700: #946302;
+    --yellow-800: #634201;
+    --yellow-900: #312101;
+
+    // Semantic colors
+    --content-primary: var(--neutral-950);
+    --content-secondary: var(--neutral-800);
+    --content-tertiary: var(--neutral-700);
+    --content-primary-inverse: var(--primary-white);
+    --content-secondary-inverse: var(--neutral-100);
+    --content-tertiary-inverse: var(--neutral-300);
+    --content-disabled: var(--neutral-300);
+    --content-brand: var(--brand-500);
+    --content-link: var(--brand-500);
+    --content-link-hover: var(--brand-400);
+    --content-link-pressed: var(--brand-600);
+    --content-warning-bold: var(--orange-700);
+    --content-danger: var(--red-500);
+    --content-danger-bold: var(--red-600);
+    --content-success: var(--green-500);
+    --content-success-bold: var(--green-600);
+    --background-primary: var(--primary-white);
+    --background-secondary: var(--neutral-50);
+    --background-tertiary: var(--neutral-100);
+    --background-hover: var(--neutral-50);
+    --background-pressed: var(--neutral-100);
+    --background-selected: var(--orange-100);
+    --background-disabled: var(--neutral-50);
+    --background-inverse: var(--neutral-900);
+    --background-brand: var(--brand-500);
+    --background-brand-hover: var(--brand-600);
+    --background-brand-pressed: var(--brand-700);
+    --background-warning: var(--orange-500);
+    --background-warning-subtle: var(--orange-50);
+    --background-danger: var(--red-500);
+    --background-danger-subtle: var(--red-50);
+    --background-success: var(--green-500);
+    --background-success-subtle: var(--green-50);
+    --border-primary: var(--neutral-600);
+    --border-secondary: var(--neutral-400);
+    --border-tertiary: var(--neutral-200);
+    --border-disabled: var(--neutral-200);
+    --border-brand: var(--brand-500);
+    --border-inverse: var(--primary-white);
+    --border-focus: var(--blue-500);
+    --border-warning: var(--orange-500);
+    --border-danger: var(--red-500);
+    --border-success: var(--green-500);
+    --overlay-50: var(--primary-black-50);
+    --overlay-50-inverse: var(--primary-white-50);
     --bg-bridge: #ebece8;
 
     // Non-color vars
@@ -143,7 +311,7 @@ $_lifecycle_dormant: map.get($colors, 'danger');
     --radius-sm: 0.25rem; // Increased from Tailwind's default of 0.125rem
     --radius-lg: 0.625rem; // Increased from Tailwind's default of 0.5rem
     --modal-shadow-elevation: 0px 16px 16px -16px rgb(0 0 0 / 35%);
-    --opacity-disabled: 0.6;
+    --opacity-disabled: 0.65;
     --font-medium: 500;
     --font-semibold: 600;
     --font-sans: -apple-system, BlinkMacSystemFont, 'Inter', 'Segoe UI', 'Roboto', 'Helvetica Neue', helvetica, arial,
diff --git a/frontend/src/toolbar/ToolbarApp.tsx b/frontend/src/toolbar/ToolbarApp.tsx
index f623736bd9c2b..80e43b38868a2 100644
--- a/frontend/src/toolbar/ToolbarApp.tsx
+++ b/frontend/src/toolbar/ToolbarApp.tsx
@@ -40,9 +40,19 @@ export function ToolbarApp(props: ToolbarProps = {}): JSX.Element {
               }
     )
 
+    // There's a small conflict between our toolbar and the Tanstack React Dev library
+    // because Tanstack is polluting the global event listeners with a mouse down listener
+    // which conflicts with our toolbar's internal mouse down listeners
+    //
+    // To workaround that we simply prevent the event from bubbling further than the toolbar
+    // See https://github.com/PostHog/posthog-js/issues/1425
+    const onMouseDown = ({ nativeEvent: event }: React.MouseEvent<HTMLDivElement>): void => {
+        event.stopImmediatePropagation()
+    }
+
     return (
         <>
-            <root.div id={TOOLBAR_ID} className="ph-no-capture" ref={shadowRef}>
+            <root.div id={TOOLBAR_ID} className="ph-no-capture" ref={shadowRef} onMouseDown={onMouseDown}>
                 <div id="posthog-toolbar-styles" />
                 {didRender && (didLoadStyles || props.disableExternalStyles) ? <ToolbarContainer /> : null}
                 <ToastContainer
diff --git a/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx b/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx
index 9922d96a70e40..1fc0a75ab189e 100644
--- a/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx
+++ b/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx
@@ -22,7 +22,7 @@ export function WebExperimentTransformHeader({
 
     return (
         <div className="flex w-full gap-4 items-center">
-            <div className="flex-1">
+            <div className="flex-1 overflow-hidden">
                 <h2>{transform.selector || 'Select element'}</h2>
             </div>
 
diff --git a/frontend/src/types.ts b/frontend/src/types.ts
index 8ad57c8964ec9..317b046e7acf6 100644
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -196,6 +196,7 @@ export enum ProductKey {
     PLATFORM_AND_SUPPORT = 'platform_and_support',
     TEAMS = 'teams',
     WEB_ANALYTICS = 'web_analytics',
+    ERROR_TRACKING = 'error_tracking',
 }
 
 type ProductKeyUnion = `${ProductKey}`
@@ -233,6 +234,10 @@ export interface ColumnConfig {
     active: ColumnChoice
 }
 
+export type WithAccessControl = {
+    user_access_level: 'none' | 'member' | 'admin' | 'viewer' | 'editor'
+}
+
 interface UserBaseType {
     uuid: string
     distinct_id: string
@@ -456,7 +461,7 @@ export interface ProjectBasicType {
     name: string
 }
 
-export interface TeamBasicType {
+export interface TeamBasicType extends WithAccessControl {
     id: number
     uuid: string
     organization: string // Organization ID
@@ -494,6 +499,7 @@ export interface ProjectType extends ProjectBasicType {
 export interface TeamSurveyConfigType {
     appearance?: SurveyAppearance
 }
+
 export interface TeamType extends TeamBasicType {
     created_at: string
     updated_at: string
@@ -2940,7 +2946,7 @@ export interface FeatureFlagBasicType {
     ensure_experience_continuity: boolean | null
 }
 
-export interface FeatureFlagType extends Omit<FeatureFlagBasicType, 'id' | 'team_id'> {
+export interface FeatureFlagType extends Omit<FeatureFlagBasicType, 'id' | 'team_id'>, WithAccessControl {
     /** Null means that the flag has never been saved yet (it's new). */
     id: number | null
     created_by: UserBasicType | null
@@ -2989,11 +2995,29 @@ export interface FeatureFlagRollbackConditions {
     operator?: string
 }
 
+export enum FeatureFlagStatus {
+    ACTIVE = 'active',
+    INACTIVE = 'inactive',
+    STALE = 'stale',
+    DELETED = 'deleted',
+    UNKNOWN = 'unknown',
+}
+
+export interface FeatureFlagStatusResponse {
+    status: FeatureFlagStatus
+    reason: string
+}
+
 export interface CombinedFeatureFlagAndValueType {
     feature_flag: FeatureFlagType
     value: boolean | string
 }
 
+export interface Feature {
+    id: number | null
+    name: string
+}
+
 export enum EarlyAccessFeatureStage {
     Draft = 'draft',
     Concept = 'concept',
@@ -3603,6 +3627,7 @@ export enum BaseMathType {
     MonthlyActiveUsers = 'monthly_active',
     UniqueSessions = 'unique_session',
     FirstTimeForUser = 'first_time_for_user',
+    FirstMatchingEventForUser = 'first_matching_event_for_user',
 }
 
 export enum PropertyMathType {
@@ -3831,7 +3856,6 @@ export interface RoleType {
     name: string
     feature_flags_access_level: AccessLevel
     members: RoleMemberType[]
-    associated_flags: { id: number; key: string }[]
     created_at: string
     created_by: UserBasicType | null
 }
@@ -3840,14 +3864,6 @@ export interface RolesListParams {
     feature_flags_access_level?: AccessLevel
 }
 
-export interface FeatureFlagAssociatedRoleType {
-    id: string
-    feature_flag: FeatureFlagType | null
-    role: RoleType
-    updated_at: string
-    added_at: string
-}
-
 export interface RoleMemberType {
     id: string
     user: UserBaseType
@@ -3888,6 +3904,50 @@ export type APIScopeObject =
     | 'user'
     | 'webhook'
 
+export interface AccessControlTypeBase {
+    created_by: UserBasicType | null
+    created_at: string
+    updated_at: string
+    resource: APIScopeObject
+    access_level: string | null // TODO: Change to enum
+    organization_member?: OrganizationMemberType['id'] | null
+    role?: RoleType['id'] | null
+}
+
+export interface AccessControlTypeProject extends AccessControlTypeBase {}
+
+export interface AccessControlTypeMember extends AccessControlTypeBase {
+    organization_member: OrganizationMemberType['id']
+}
+
+export interface AccessControlTypeRole extends AccessControlTypeBase {
+    role: RoleType['id']
+}
+
+export type AccessControlType = AccessControlTypeProject | AccessControlTypeMember | AccessControlTypeRole
+
+export type AccessControlUpdateType = Pick<AccessControlType, 'access_level' | 'organization_member' | 'role'> & {
+    resource?: AccessControlType['resource']
+}
+
+export type AccessControlResponseType = {
+    access_controls: AccessControlType[]
+    available_access_levels: string[] // TODO: Change to enum
+    user_access_level: string
+    default_access_level: string
+    user_can_edit_access_levels: boolean
+}
+
+// TODO: To be deprecated
+export interface FeatureFlagAssociatedRoleType {
+    id: string
+    feature_flag: FeatureFlagType | null
+    role: RoleType
+    updated_at: string
+    added_at: string
+}
+// TODO: To be deprecated
+
 export interface OrganizationResourcePermissionType {
     id: string
     resource: Resource
@@ -3930,6 +3990,7 @@ export type PromptFlag = {
 
 // Should be kept in sync with "posthog/models/activity_logging/activity_log.py"
 export enum ActivityScope {
+    ACTION = 'Action',
     FEATURE_FLAG = 'FeatureFlag',
     PERSON = 'Person',
     INSIGHT = 'Insight',
@@ -3973,12 +4034,13 @@ export type NotebookListItemType = {
     last_modified_by?: UserBasicType | null
 }
 
-export type NotebookType = NotebookListItemType & {
-    content: JSONContent | null
-    version: number
-    // used to power text-based search
-    text_content?: string | null
-}
+export type NotebookType = NotebookListItemType &
+    WithAccessControl & {
+        content: JSONContent | null
+        version: number
+        // used to power text-based search
+        text_content?: string | null
+    }
 
 export enum NotebookNodeType {
     Mention = 'ph-mention',
@@ -4426,6 +4488,7 @@ export enum SidePanelTab {
     Discussion = 'discussion',
     Status = 'status',
     Exports = 'exports',
+    // AccessControl = 'access-control',
 }
 
 export interface SourceFieldOauthConfig {
@@ -4542,6 +4605,7 @@ export type HogFunctionInputSchemaType = {
     integration?: string
     integration_key?: string
     integration_field?: 'slack_channel'
+    requiredScopes?: string
 }
 
 export type HogFunctionInputType = {
@@ -4591,10 +4655,21 @@ export interface HogFunctionFiltersType {
     bytecode_error?: string
 }
 
+export interface HogFunctionMappingType {
+    inputs_schema?: HogFunctionInputSchemaType[]
+    inputs?: Record<string, HogFunctionInputType> | null
+    filters?: HogFunctionFiltersType | null
+}
+export interface HogFunctionMappingTemplateType extends HogFunctionMappingType {
+    name: string
+    include_by_default?: boolean
+}
+
 export type HogFunctionTypeType =
     | 'destination'
     | 'site_destination'
     | 'site_app'
+    | 'transformation'
     | 'email'
     | 'sms'
     | 'push'
@@ -4616,6 +4691,7 @@ export type HogFunctionType = {
 
     inputs_schema?: HogFunctionInputSchemaType[]
     inputs?: Record<string, HogFunctionInputType> | null
+    mappings?: HogFunctionMappingType[] | null
     masking?: HogFunctionMasking | null
     filters?: HogFunctionFiltersType | null
     template?: HogFunctionTemplateType
@@ -4633,7 +4709,7 @@ export type HogFunctionConfigurationType = Omit<
     sub_template_id?: HogFunctionSubTemplateIdType
 }
 
-export type HogFunctionSubTemplateType = Pick<HogFunctionType, 'filters' | 'inputs' | 'masking'> & {
+export type HogFunctionSubTemplateType = Pick<HogFunctionType, 'filters' | 'inputs' | 'masking' | 'mappings'> & {
     id: HogFunctionSubTemplateIdType
     name: string
     description: string | null
@@ -4641,10 +4717,11 @@ export type HogFunctionSubTemplateType = Pick<HogFunctionType, 'filters' | 'inpu
 
 export type HogFunctionTemplateType = Pick<
     HogFunctionType,
-    'id' | 'type' | 'name' | 'description' | 'hog' | 'inputs_schema' | 'filters' | 'icon_url' | 'masking'
+    'id' | 'type' | 'name' | 'description' | 'hog' | 'inputs_schema' | 'filters' | 'icon_url' | 'masking' | 'mappings'
 > & {
     status: HogFunctionTemplateStatus
     sub_templates?: HogFunctionSubTemplateType[]
+    mapping_templates?: HogFunctionMappingTemplateType[]
 }
 
 export type HogFunctionIconResponse = {
@@ -4751,3 +4828,10 @@ export type ReplayTemplateVariableType = {
     filterGroup?: UniversalFiltersGroupValue
     noTouch?: boolean
 }
+
+/**
+ * Assistant Conversation
+ */
+export interface Conversation {
+    id: string
+}
diff --git a/funnel-udf/src/steps.rs b/funnel-udf/src/steps.rs
index 21d6fb84e62e8..e2ba45ae02cd0 100644
--- a/funnel-udf/src/steps.rs
+++ b/funnel-udf/src/steps.rs
@@ -217,7 +217,7 @@ impl AggregateFunnelRow {
                         }
                     }
                 } else {
-                    let is_unmatched_step_attribution = self.breakdown_step.map(|breakdown_step| step == breakdown_step - 1).unwrap_or(false) && *prop_val != event.breakdown;
+                    let is_unmatched_step_attribution = self.breakdown_step.map(|breakdown_step| step - 1 == breakdown_step).unwrap_or(false) && *prop_val != event.breakdown;
                     let already_used_event = processing_multiple_events && vars.entered_timestamp[step - 1].uuids.contains(&event.uuid);
                     if !is_unmatched_step_attribution && !already_used_event {
                         let new_entered_timestamp = |vars: &Vars| -> EnteredTimestamp {
diff --git a/funnel-udf/src/trends.rs b/funnel-udf/src/trends.rs
index 42356dc06d1aa..737bb82f48b8c 100644
--- a/funnel-udf/src/trends.rs
+++ b/funnel-udf/src/trends.rs
@@ -66,13 +66,15 @@ struct IntervalData {
     entered_timestamp: Vec<EnteredTimestamp>,
 }
 
+type ResultsMap = HashMap<u64, ResultStruct>;
+
 struct Vars {
     interval_start_to_entered_timestamps: HashMap<u64, IntervalData>,
+    results: ResultsMap,
 }
 
 struct AggregateFunnelRow {
     breakdown_step: Option<usize>,
-    results: HashMap<u64, ResultStruct>,
 }
 
 const DEFAULT_ENTERED_TIMESTAMP: EnteredTimestamp = EnteredTimestamp {
@@ -83,11 +85,9 @@ const DEFAULT_ENTERED_TIMESTAMP: EnteredTimestamp = EnteredTimestamp {
 pub fn process_line(line: &str) -> Value {
     let args = parse_args(line);
     let mut aggregate_funnel_row = AggregateFunnelRow {
-        results: HashMap::new(),
         breakdown_step: Option::None,
     };
-    aggregate_funnel_row.calculate_funnel_from_user_events(&args);
-    let result: Vec<ResultStruct> = aggregate_funnel_row.results.into_values().collect();
+    let result: Vec<ResultStruct> = aggregate_funnel_row.calculate_funnel_from_user_events(&args);
     json!({ "result": result })
 }
 
@@ -98,17 +98,21 @@ fn parse_args(line: &str) -> Args {
 
 impl AggregateFunnelRow {
     #[inline(always)]
-    fn calculate_funnel_from_user_events(&mut self, args: &Args) {
+    fn calculate_funnel_from_user_events(&mut self, args: &Args) -> Vec<ResultStruct> {
         if args.breakdown_attribution_type.starts_with("step_") {
             self.breakdown_step = args.breakdown_attribution_type[5..].parse::<usize>().ok()
         }
 
-        args.prop_vals.iter().for_each(|prop_val| self.loop_prop_val(args, prop_val));
+        args.prop_vals.iter().flat_map(|prop_val| {
+            let results_map= self.loop_prop_val(args, prop_val);
+            results_map.into_values().collect::<Vec<ResultStruct>>()
+        }).collect()
     }
 
     #[inline(always)]
-    fn loop_prop_val(&mut self, args: &Args, prop_val: &PropVal) {
+    fn loop_prop_val(&mut self, args: &Args, prop_val: &PropVal) -> ResultsMap {
         let mut vars = Vars {
+            results: HashMap::new(),
             interval_start_to_entered_timestamps: HashMap::new(),
         };
 
@@ -139,11 +143,13 @@ impl AggregateFunnelRow {
         let fully_excluded = vars.interval_start_to_entered_timestamps.values().find(|interval_data| interval_data.max_step.excluded == Exclusion::Full);
         if fully_excluded.is_none() {
             for (interval_start, interval_data) in vars.interval_start_to_entered_timestamps.into_iter() {
-                if !self.results.contains_key(&interval_start) && interval_data.max_step.step >= args.from_step + 1 && interval_data.max_step.excluded != Exclusion::Partial {
-                    self.results.insert(interval_start, ResultStruct(interval_start, -1, prop_val.clone(), interval_data.max_step.event_uuid));
+                if !vars.results.contains_key(&interval_start) && interval_data.max_step.step >= args.from_step + 1 && interval_data.max_step.excluded != Exclusion::Partial {
+                    vars.results.insert(interval_start, ResultStruct(interval_start, -1, prop_val.clone(), interval_data.max_step.event_uuid));
                 }
             }
         }
+
+        vars.results
     }
 
     #[inline(always)]
@@ -163,8 +169,10 @@ impl AggregateFunnelRow {
                 *step
             }) as usize;
 
+            let is_unmatched_step_attribution = self.breakdown_step.map(|breakdown_step| step - 1 == breakdown_step).unwrap_or(false) && *prop_val != event.breakdown;
+
             if step == 1 {
-                if !self.results.contains_key(&event.interval_start) {
+                if !is_unmatched_step_attribution && !vars.results.contains_key(&event.interval_start) {
                     let entered_timestamp_one = EnteredTimestamp { timestamp: event.timestamp, excluded: false };
                     let interval = vars.interval_start_to_entered_timestamps.get_mut(&event.interval_start);
                     if interval.is_none() || interval.as_ref().map( | interval | interval.max_step.step == 1 && interval.max_step.excluded != Exclusion::Not).unwrap() {
@@ -201,7 +209,6 @@ impl AggregateFunnelRow {
                                 }
                             }
                         } else {
-                            let is_unmatched_step_attribution = self.breakdown_step.map(|breakdown_step| step == breakdown_step - 1).unwrap_or(false) && *prop_val != event.breakdown;
                             if !is_unmatched_step_attribution {
                                 if !previous_step_excluded {
                                     interval_data.entered_timestamp[step] = EnteredTimestamp {
@@ -211,7 +218,7 @@ impl AggregateFunnelRow {
                                 }
                                 // check if we have hit the goal. if we have, remove it from the list and add it to the successful_timestamps
                                 if interval_data.entered_timestamp[args.num_steps].timestamp != 0.0 {
-                                    self.results.insert(
+                                    vars.results.insert(
                                         interval_start,
                                         ResultStruct(interval_start, 1, prop_val.clone(), event.uuid)
                                     );
diff --git a/hogvm/typescript/package.json b/hogvm/typescript/package.json
index 4e3af57e59561..c0c554a9133cc 100644
--- a/hogvm/typescript/package.json
+++ b/hogvm/typescript/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@posthog/hogvm",
-    "version": "1.0.61",
+    "version": "1.0.64",
     "description": "PostHog Hog Virtual Machine",
     "types": "dist/index.d.ts",
     "source": "src/index.ts",
diff --git a/livestream/go.mod b/livestream/go.mod
index 0efed981a97d6..4f65785855d82 100644
--- a/livestream/go.mod
+++ b/livestream/go.mod
@@ -55,10 +55,10 @@ require (
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/crypto v0.31.0 // indirect
 	golang.org/x/net v0.25.0 // indirect
-	golang.org/x/sys v0.20.0 // indirect
-	golang.org/x/text v0.15.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
 	golang.org/x/time v0.5.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/livestream/go.sum b/livestream/go.sum
index 4a523d7facffd..f3065be13f840 100644
--- a/livestream/go.sum
+++ b/livestream/go.sum
@@ -386,31 +386,31 @@ go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
 go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
-golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/exp v0.0.0-20240119083558-1b970713d09a h1:Q8/wZp0KX97QFTc2ywcOE0YRjZPVIx+MXInMzdvQqcA=
 golang.org/x/exp v0.0.0-20240119083558-1b970713d09a/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08=
-golang.org/x/mod v0.16.0 h1:QX4fJ0Rr5cPQCF7O9lh9Se4pmwfwskqZfq5moyldzic=
-golang.org/x/mod v0.16.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/oauth2 v0.16.0 h1:aDkGMBSYxElaoP81NpoUoz2oo2R2wHdZpGToUxfyQrQ=
 golang.org/x/oauth2 v0.16.0/go.mod h1:hqZ+0LWXsiVoZpeld6jVt06P3adbS2Uu911W1SsJv2o=
-golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
 golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
-golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc=
-golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
 google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds=
 google.golang.org/genproto v0.0.0-20240325203815-454cdb8f5daa h1:ePqxpG3LVx+feAUOx8YmR5T7rc0rdzK8DyxM8cQ9zq0=
diff --git a/mypy-baseline.txt b/mypy-baseline.txt
index 96984826e9c5a..4599145228cfa 100644
--- a/mypy-baseline.txt
+++ b/mypy-baseline.txt
@@ -1,67 +1,4 @@
 posthog/warehouse/models/ssh_tunnel.py:0: error: Incompatible types in assignment (expression has type "NoEncryption", variable has type "BestAvailableEncryption")  [assignment]
-posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py:0: error: Statement is unreachable  [unreachable]
-posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py:0: error: Non-overlapping equality check (left operand type: "Literal['text', 'double', 'bool', 'timestamp', 'bigint', 'json', 'decimal', 'wei', 'date', 'time'] | None", right operand type: "Literal['interval']")  [comparison-overlap]
-posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Invalid index type "str | None" for "dict[str, ndarray[Any, dtype[Any]]]"; expected type "str"  [index]
-posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Invalid index type "str | None" for "dict[str, ndarray[Any, dtype[Any]]]"; expected type "str"  [index]
-posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Invalid index type "str | None" for "dict[str, TColumnSchema]"; expected type "str"  [index]
-posthog/temporal/data_imports/pipelines/sql_database/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Item "None" of "Incremental[Any] | None" has no attribute "row_order"  [union-attr]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Incompatible types in assignment (expression has type "Literal['asc', 'desc'] | Any | None", variable has type "Literal['asc', 'desc']")  [assignment]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "Column[Any]")  [assignment]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "Literal['asc', 'desc']")  [assignment]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Item "None" of "dict[str, Any] | None" has no attribute "get"  [union-attr]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Argument "primary_key" to "make_hints" has incompatible type "list[str] | None"; expected "str | Sequence[str] | Callable[[Any], str | Sequence[str]]"  [arg-type]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Dict entry 2 has incompatible type "Literal['auto']": "None"; expected "Literal['json_response', 'header_link', 'auto', 'single_page', 'cursor', 'offset', 'page_number']": "type[BasePaginator]"  [dict-item]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "AuthConfigBase")  [assignment]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Argument 1 to "get_auth_class" has incompatible type "Literal['bearer', 'api_key', 'http_basic'] | None"; expected "Literal['bearer', 'api_key', 'http_basic']"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Need type annotation for "dependency_graph"  [var-annotated]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "None", target has type "ResolvedParam")  [assignment]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible return value type (got "tuple[TopologicalSorter[Any], dict[str, EndpointResource], dict[str, ResolvedParam]]", expected "tuple[Any, dict[str, EndpointResource], dict[str, ResolvedParam | None]]")  [return-value]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unsupported right operand type for in ("str | Endpoint | None")  [operator]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Value of type variable "StrOrLiteralStr" of "parse" of "Formatter" cannot be "str | None"  [type-var]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unsupported right operand type for in ("dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None")  [operator]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unsupported right operand type for in ("dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None")  [operator]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Value of type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" is not indexable  [index]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Item "None" of "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" has no attribute "pop"  [union-attr]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Value of type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" is not indexable  [index]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Item "None" of "str | None" has no attribute "format"  [union-attr]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Argument 1 to "single_entity_path" has incompatible type "str | None"; expected "str"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Item "None" of "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" has no attribute "items"  [union-attr]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "str | None", variable has type "str")  [assignment]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "str | None", variable has type "str")  [assignment]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Statement is unreachable  [unreachable]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 0 has incompatible type "dict[str, Any] | None"; expected "SupportsKeysAndGetItem[str, Any]"  [dict-item]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 1 has incompatible type "dict[str, Any] | None"; expected "SupportsKeysAndGetItem[str, Any]"  [dict-item]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 0 has incompatible type "dict[str, Any] | None"; expected "SupportsKeysAndGetItem[str, ResolveParamConfig | IncrementalParamConfig | Any]"  [dict-item]
-posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 1 has incompatible type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None"; expected "SupportsKeysAndGetItem[str, ResolveParamConfig | IncrementalParamConfig | Any]"  [dict-item]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Not all union combinations were tried because there are too many unions  [misc]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 2 to "source" has incompatible type "str | None"; expected "str"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 3 to "source" has incompatible type "str | None"; expected "str"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 4 to "source" has incompatible type "int | None"; expected "int"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 6 to "source" has incompatible type "Schema | None"; expected "Schema"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 7 to "source" has incompatible type "Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | None"; expected "Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 8 to "source" has incompatible type "type[BaseConfiguration] | None"; expected "type[BaseConfiguration]"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 1 to "build_resource_dependency_graph" has incompatible type "EndpointResourceBase | None"; expected "EndpointResourceBase"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Incompatible types in assignment (expression has type "list[str] | None", variable has type "list[str]")  [assignment]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 1 to "setup_incremental_object" has incompatible type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None"; expected "dict[str, Any]"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument "base_url" to "RESTClient" has incompatible type "str | None"; expected "str"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 1 to "exclude_keys" has incompatible type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None"; expected "Mapping[str, Any]"  [arg-type]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Incompatible default for argument "resolved_param" (default has type "ResolvedParam | None", argument has type "ResolvedParam")  [assignment]
-posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/utils.py:0: error: No overload variant of "asdict" matches argument type "type[DataclassInstance]"  [call-overload]
 posthog/utils.py:0: note: Possible overload variants:
 posthog/utils.py:0: note: def asdict(obj: DataclassInstance) -> dict[str, Any]
@@ -108,8 +45,6 @@ posthog/hogql/parser.py:0: error: Item "None" of "list[Expr] | None" has no attr
 posthog/hogql/parser.py:0: error: "None" has no attribute "text"  [attr-defined]
 posthog/hogql/parser.py:0: error: "None" has no attribute "text"  [attr-defined]
 posthog/hogql/parser.py:0: error: Statement is unreachable  [unreachable]
-posthog/hogql/functions/cohort.py:0: error: Incompatible type for lookup 'team_id': (got "int | None", expected "str | int")  [misc]
-posthog/hogql/functions/cohort.py:0: error: Incompatible type for lookup 'team_id': (got "int | None", expected "str | int")  [misc]
 posthog/hogql/database/schema/persons_pdi.py:0: error: Incompatible types in assignment (expression has type "Organization | None", variable has type "Organization")  [assignment]
 posthog/hogql/database/schema/groups.py:0: error: Incompatible types in assignment (expression has type "dict[str, DatabaseField]", variable has type "dict[str, FieldOrTable]")  [assignment]
 posthog/hogql/database/schema/groups.py:0: note: "Dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
@@ -145,12 +80,11 @@ posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Item "No
 posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Argument 1 to "float" has incompatible type "Any | None"; expected "str | Buffer | SupportsFloat | SupportsIndex"  [arg-type]
 posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Argument 1 to "clean_display" has incompatible type "Any | None"; expected "str"  [arg-type]
 posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Dict entry 0 has incompatible type "str": "FunnelsFilter"; expected "str": "TrendsFilter"  [dict-item]
-posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Dict entry 0 has incompatible type "str": "RetentionFilter"; expected "str": "TrendsFilter"  [dict-item]
-posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Argument 1 to "to_base_entity_dict" has incompatible type "Any | None"; expected "dict[Any, Any]"  [arg-type]
-posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Argument 1 to "to_base_entity_dict" has incompatible type "Any | None"; expected "dict[Any, Any]"  [arg-type]
 posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Dict entry 0 has incompatible type "str": "PathsFilter"; expected "str": "TrendsFilter"  [dict-item]
 posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Dict entry 0 has incompatible type "str": "LifecycleFilter"; expected "str": "TrendsFilter"  [dict-item]
 posthog/hogql_queries/legacy_compatibility/filter_to_query.py:0: error: Dict entry 0 has incompatible type "str": "StickinessFilter"; expected "str": "TrendsFilter"  [dict-item]
+posthog/warehouse/models/external_data_schema.py:0: error: Incompatible types in assignment (expression has type "str", variable has type "int | float")  [assignment]
+posthog/warehouse/models/external_data_schema.py:0: error: Incompatible types in assignment (expression has type "str", variable has type "int | float")  [assignment]
 posthog/session_recordings/models/session_recording.py:0: error: Argument "distinct_id" to "MissingPerson" has incompatible type "str | None"; expected "str"  [arg-type]
 posthog/session_recordings/models/session_recording.py:0: error: Incompatible type for lookup 'persondistinctid__team_id': (got "Team", expected "str | int")  [misc]
 posthog/models/hog_functions/hog_function.py:0: error: Argument 1 to "get" of "dict" has incompatible type "str | None"; expected "str"  [arg-type]
@@ -220,13 +154,9 @@ posthog/hogql/transforms/lazy_tables.py:0: error: Incompatible types in assignme
 posthog/hogql/transforms/in_cohort.py:0: error: Incompatible default for argument "context" (default has type "None", argument has type "HogQLContext")  [assignment]
 posthog/hogql/transforms/in_cohort.py:0: note: PEP 484 prohibits implicit Optional. Accordingly, mypy has changed its default to no_implicit_optional=True
 posthog/hogql/transforms/in_cohort.py:0: note: Use https://github.com/hauntsaninja/no_implicit_optional to automatically upgrade your codebase
-posthog/hogql/transforms/in_cohort.py:0: error: Incompatible type for lookup 'team_id': (got "int | None", expected "str | int")  [misc]
-posthog/hogql/transforms/in_cohort.py:0: error: Incompatible type for lookup 'team_id': (got "int | None", expected "str | int")  [misc]
 posthog/hogql/transforms/in_cohort.py:0: error: Incompatible default for argument "context" (default has type "None", argument has type "HogQLContext")  [assignment]
 posthog/hogql/transforms/in_cohort.py:0: note: PEP 484 prohibits implicit Optional. Accordingly, mypy has changed its default to no_implicit_optional=True
 posthog/hogql/transforms/in_cohort.py:0: note: Use https://github.com/hauntsaninja/no_implicit_optional to automatically upgrade your codebase
-posthog/hogql/transforms/in_cohort.py:0: error: Incompatible type for lookup 'team_id': (got "int | None", expected "str | int")  [misc]
-posthog/hogql/transforms/in_cohort.py:0: error: Incompatible type for lookup 'team_id': (got "int | None", expected "str | int")  [misc]
 posthog/hogql/transforms/in_cohort.py:0: error: Argument "table" to "JoinExpr" has incompatible type "Expr"; expected "SelectQuery | SelectSetQuery | Field | None"  [arg-type]
 posthog/hogql/transforms/in_cohort.py:0: error: List item 0 has incompatible type "SelectQueryType | None"; expected "SelectQueryType"  [list-item]
 posthog/hogql/transforms/in_cohort.py:0: error: Item "None" of "JoinConstraint | None" has no attribute "expr"  [union-attr]
@@ -288,10 +218,6 @@ posthog/demo/matrix/matrix.py:0: error: Name "timezone.datetime" is not defined
 posthog/demo/matrix/matrix.py:0: error: Name "timezone.datetime" is not defined  [name-defined]
 posthog/demo/matrix/matrix.py:0: error: Name "timezone.datetime" is not defined  [name-defined]
 posthog/api/shared.py:0: error: Incompatible return value type (got "int | None", expected "Level | None")  [return-value]
-ee/billing/quota_limiting.py:0: error: Unsupported target for indexed assignment ("object")  [index]
-ee/billing/quota_limiting.py:0: error: "object" has no attribute "get"  [attr-defined]
-ee/billing/quota_limiting.py:0: error: Unsupported target for indexed assignment ("object")  [index]
-ee/billing/quota_limiting.py:0: error: Unsupported target for indexed assignment ("object")  [index]
 posthog/test/base.py:0: error: Module has no attribute "configure"  [attr-defined]
 posthog/test/base.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "Organization")  [assignment]
 posthog/test/base.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "Project")  [assignment]
@@ -317,12 +243,10 @@ ee/tasks/subscriptions/email_subscriptions.py:0: error: Item "None" of "User | N
 ee/tasks/subscriptions/email_subscriptions.py:0: error: Item "None" of "datetime | None" has no attribute "isoformat"  [union-attr]
 ee/tasks/subscriptions/email_subscriptions.py:0: error: Item "None" of "datetime | None" has no attribute "strftime"  [union-attr]
 ee/tasks/subscriptions/email_subscriptions.py:0: error: Item "None" of "User | None" has no attribute "first_name"  [union-attr]
-ee/billing/billing_manager.py:0: error: Module has no attribute "utc"  [attr-defined]
-ee/billing/billing_manager.py:0: error: Incompatible types in assignment (expression has type "object", variable has type "bool | Combinable | None")  [assignment]
 posthog/models/property/util.py:0: error: Incompatible type for lookup 'pk': (got "str | int | list[str]", expected "str | int")  [misc]
 posthog/models/property/util.py:0: error: Argument 3 to "format_filter_query" has incompatible type "HogQLContext | None"; expected "HogQLContext"  [arg-type]
 posthog/models/property/util.py:0: error: Argument 3 to "format_cohort_subquery" has incompatible type "HogQLContext | None"; expected "HogQLContext"  [arg-type]
-posthog/models/property/util.py:0: error: Invalid index type "tuple[str, str]" for "dict[tuple[str, Literal['properties', 'group_properties', 'person_properties']], str]"; expected type "tuple[str, Literal['properties', 'group_properties', 'person_properties']]"  [index]
+posthog/models/property/util.py:0: error: Argument 2 to "get_materialized_column_for_property" has incompatible type "str"; expected "Literal['properties', 'group_properties', 'person_properties']"  [arg-type]
 posthog/models/property/util.py:0: error: Argument 1 to "append" of "list" has incompatible type "str | int"; expected "str"  [arg-type]
 posthog/models/property/util.py:0: error: Argument 1 to "append" of "list" has incompatible type "str | int"; expected "str"  [arg-type]
 posthog/models/property/util.py:0: error: Argument 1 to "append" of "list" has incompatible type "str | int"; expected "str"  [arg-type]
@@ -332,20 +256,26 @@ posthog/api/documentation.py:0: note: def run_validation(self, data: Any = ...)
 posthog/api/documentation.py:0: note: Subclass:
 posthog/api/documentation.py:0: note: def run_validation(self, data: Any) -> Any
 posthog/queries/trends/util.py:0: error: Argument 1 to "translate_hogql" has incompatible type "str | None"; expected "str"  [arg-type]
-posthog/queries/column_optimizer/foss_column_optimizer.py:0: error: Argument 1 to "get" of "dict" has incompatible type "tuple[str, str]"; expected "tuple[str, Literal['properties', 'group_properties', 'person_properties']]"  [arg-type]
+posthog/queries/column_optimizer/foss_column_optimizer.py:0: error: Argument 2 to "get_materialized_column_for_property" has incompatible type "str"; expected "Literal['properties', 'group_properties', 'person_properties']"  [arg-type]
 posthog/hogql/property.py:0: error: Incompatible type for lookup 'id': (got "str | int | list[str]", expected "str | int")  [misc]
 posthog/hogql/property.py:0: error: Incompatible type for lookup 'pk': (got "str | float", expected "str | int")  [misc]
 posthog/api/utils.py:0: error: Incompatible types in assignment (expression has type "type[EventDefinition]", variable has type "type[EnterpriseEventDefinition]")  [assignment]
 posthog/api/utils.py:0: error: Argument 1 to "UUID" has incompatible type "int | str"; expected "str | None"  [arg-type]
+ee/billing/quota_limiting.py:0: error: Unsupported target for indexed assignment ("object")  [index]
+ee/billing/quota_limiting.py:0: error: "object" has no attribute "get"  [attr-defined]
+ee/billing/quota_limiting.py:0: error: Unsupported target for indexed assignment ("object")  [index]
+ee/billing/quota_limiting.py:0: error: Unsupported target for indexed assignment ("object")  [index]
 posthog/hogql/filters.py:0: error: Incompatible default for argument "team" (default has type "None", argument has type "Team")  [assignment]
 posthog/hogql/filters.py:0: note: PEP 484 prohibits implicit Optional. Accordingly, mypy has changed its default to no_implicit_optional=True
 posthog/hogql/filters.py:0: note: Use https://github.com/hauntsaninja/no_implicit_optional to automatically upgrade your codebase
-posthog/api/capture.py:0: error: Module has no attribute "utc"  [attr-defined]
+ee/billing/billing_manager.py:0: error: Module has no attribute "utc"  [attr-defined]
+ee/billing/billing_manager.py:0: error: Incompatible types in assignment (expression has type "object", variable has type "bool | Combinable | None")  [assignment]
 posthog/hogql/query.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "str | SelectQuery | SelectSetQuery")  [assignment]
 posthog/hogql/query.py:0: error: Incompatible types in assignment (expression has type "Expr", variable has type "SelectQuery | SelectSetQuery")  [assignment]
 posthog/hogql/query.py:0: error: Argument 1 to "get_default_limit_for_context" has incompatible type "LimitContext | None"; expected "LimitContext"  [arg-type]
 posthog/hogql/query.py:0: error: Subclass of "SelectQuery" and "SelectSetQuery" cannot exist: would have incompatible method signatures  [unreachable]
 posthog/api/organization.py:0: error: Incompatible return value type (got "int | None", expected "Level | None")  [return-value]
+posthog/api/capture.py:0: error: Module has no attribute "utc"  [attr-defined]
 posthog/queries/person_query.py:0: error: Incompatible type for lookup 'pk': (got "str | int | list[str]", expected "str | int")  [misc]
 posthog/queries/event_query/event_query.py:0: error: Incompatible type for lookup 'pk': (got "str | int | list[str]", expected "str | int")  [misc]
 posthog/hogql_queries/sessions_timeline_query_runner.py:0: error: Statement is unreachable  [unreachable]
@@ -409,7 +339,6 @@ posthog/hogql_queries/insights/funnels/funnels_query_runner.py:0: error: Module
 posthog/api/survey.py:0: error: Incompatible types in assignment (expression has type "Any | Sequence[Any] | None", variable has type "Survey | None")  [assignment]
 posthog/api/survey.py:0: error: Item "list[_ErrorFullDetails]" of "_FullDetailDict | list[_ErrorFullDetails] | dict[str, _ErrorFullDetails]" has no attribute "get"  [union-attr]
 posthog/api/survey.py:0: error: Item "object" of "object | Any" has no attribute "__iter__" (not iterable)  [union-attr]
-posthog/hogql_queries/web_analytics/web_overview.py:0: error: Module "django.utils.timezone" does not explicitly export attribute "datetime"  [attr-defined]
 posthog/api/user.py:0: error: Module has no attribute "utc"  [attr-defined]
 posthog/api/user.py:0: error: Module has no attribute "utc"  [attr-defined]
 posthog/api/user.py:0: error: "User" has no attribute "social_auth"  [attr-defined]
@@ -436,40 +365,9 @@ posthog/test/test_feature_flag_analytics.py:0: error: Item "None" of "Dashboard
 posthog/test/test_feature_flag_analytics.py:0: error: Item "None" of "Dashboard | None" has no attribute "tiles"  [union-attr]
 posthog/test/test_feature_flag_analytics.py:0: error: Item "None" of "Dashboard | None" has no attribute "tiles"  [union-attr]
 posthog/test/test_feature_flag_analytics.py:0: error: Item "None" of "Dashboard | None" has no attribute "delete"  [union-attr]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: error: No overload variant of "with_only_columns" of "Select" matches argument type "ReadOnlyColumnCollection[str, Column[Any]]"  [call-overload]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: Possible overload variants:
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], /) -> Select[tuple[_T0]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], /) -> Select[tuple[_T0, _T1]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], /) -> Select[tuple[_T0, _T1, _T2]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], /) -> Select[tuple[_T0, _T1, _T2, _T3]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4, _T5] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], TypedColumnsClauseRole[_T5] | SQLCoreOperations[_T5] | type[_T5], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4, _T5]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4, _T5, _T6] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], TypedColumnsClauseRole[_T5] | SQLCoreOperations[_T5] | type[_T5], TypedColumnsClauseRole[_T6] | SQLCoreOperations[_T6] | type[_T6], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], TypedColumnsClauseRole[_T5] | SQLCoreOperations[_T5] | type[_T5], TypedColumnsClauseRole[_T6] | SQLCoreOperations[_T6] | type[_T6], TypedColumnsClauseRole[_T7] | SQLCoreOperations[_T7] | type[_T7], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def with_only_columns(self, *entities: TypedColumnsClauseRole[Any] | ColumnsClauseRole | SQLCoreOperations[Any] | Literal['*', 1] | type[Any] | Inspectable[_HasClauseElement[Any]] | _HasClauseElement[Any], maintain_column_froms: bool = ..., **Any) -> Select[Any]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: error: No overload variant of "resource" matches argument types "Callable[[Engine, Table, int, Literal['sqlalchemy', 'pyarrow', 'pandas', 'connectorx'], Incremental[Any] | None, bool, Callable[[Table], None] | None, Literal['minimal', 'full', 'full_with_precision'], dict[str, Any] | None, Callable[[TypeEngine[Any]], TypeEngine[Any] | type[TypeEngine[Any]] | None] | None, list[str] | None, Callable[[Select[Any], Table], Select[Any]] | None, list[str] | None], Iterator[Any]]", "str", "list[str] | None", "list[str] | None", "dict[str, TColumnSchema]", "Collection[str]", "str"  [call-overload]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: Possible overload variants:
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TResourceFunParams`-1, TDltResourceImpl: DltResource] resource(Callable[TResourceFunParams, Any], /, name: str = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ...) -> TDltResourceImpl
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TDltResourceImpl: DltResource] resource(None = ..., /, name: str = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ...) -> Callable[[Callable[TResourceFunParams, Any]], TDltResourceImpl]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TDltResourceImpl: DltResource] resource(None = ..., /, name: str | Callable[[Any], str] = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ..., standalone: Literal[True] = ...) -> Callable[[Callable[TResourceFunParams, Any]], Callable[TResourceFunParams, TDltResourceImpl]]
-posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TDltResourceImpl: DltResource] resource(list[Any] | tuple[Any] | Iterator[Any], /, name: str = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ...) -> TDltResourceImpl
+posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py:0: error: Statement is unreachable  [unreachable]
+posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py:0: error: Non-overlapping equality check (left operand type: "Literal['text', 'double', 'bool', 'timestamp', 'bigint', 'json', 'decimal', 'wei', 'date', 'time'] | None", right operand type: "Literal['interval']")  [comparison-overlap]
+posthog/temporal/data_imports/pipelines/sql_database/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/tasks/test/test_update_survey_iteration.py:0: error: Item "None" of "FeatureFlag | None" has no attribute "filters"  [union-attr]
 posthog/tasks/test/test_stop_surveys_reached_target.py:0: error: No overload variant of "__sub__" of "datetime" matches argument type "None"  [operator]
 posthog/tasks/test/test_stop_surveys_reached_target.py:0: note: Possible overload variants:
@@ -496,6 +394,10 @@ posthog/tasks/exports/test/test_csv_exporter_renders.py:0: error: Item "memoryvi
 posthog/tasks/exports/test/test_csv_exporter_renders.py:0: error: Item "None" of "bytes | memoryview | None" has no attribute "decode"  [union-attr]
 posthog/tasks/exports/test/test_csv_exporter_renders.py:0: error: Item "memoryview" of "bytes | memoryview | None" has no attribute "decode"  [union-attr]
 posthog/tasks/exports/test/test_csv_exporter_renders.py:0: error: Item "None" of "bytes | memoryview | None" has no attribute "decode"  [union-attr]
+posthog/management/commands/warehouse_last_incremental_value_sync.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/management/commands/warehouse_last_incremental_value_sync.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/management/commands/warehouse_last_incremental_value_sync.py:0: error: Argument 3 to "get_value" of "ConfigProvider" has incompatible type "str | None"; expected "str"  [arg-type]
+posthog/management/commands/warehouse_last_incremental_value_sync.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/management/commands/sync_persons_to_clickhouse.py:0: error: Argument 4 to "create_person_override" has incompatible type "int | None"; expected "int"  [arg-type]
 posthog/management/commands/sync_persons_to_clickhouse.py:0: error: Argument "group_type_index" to "raw_create_group_ch" has incompatible type "int"; expected "Literal[0, 1, 2, 3, 4]"  [arg-type]
 posthog/management/commands/migrate_team.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "BatchExport")  [assignment]
@@ -603,22 +505,10 @@ posthog/warehouse/data_load/validate_schema.py:0: error: Incompatible types in a
 posthog/warehouse/data_load/validate_schema.py:0: error: Incompatible types in assignment (expression has type "object", variable has type "str | int | Combinable")  [assignment]
 posthog/warehouse/data_load/validate_schema.py:0: error: Incompatible types in assignment (expression has type "dict[str, dict[str, str | bool]] | dict[str, str]", variable has type "dict[str, dict[str, str]]")  [assignment]
 posthog/warehouse/data_load/source_templates.py:0: error: Incompatible types in assignment (expression has type "str", variable has type "Type")  [assignment]
-posthog/warehouse/api/external_data_schema.py:0: error: Incompatible return value type (got "str | None", expected "SyncType | None")  [return-value]
-posthog/warehouse/api/external_data_schema.py:0: error: Argument 1 to "get_sql_schemas_for_source_type" has incompatible type "str"; expected "Type"  [arg-type]
-posthog/warehouse/api/external_data_schema.py:0: error: No overload variant of "get" of "dict" matches argument type "str"  [call-overload]
-posthog/warehouse/api/external_data_schema.py:0: note: Possible overload variants:
-posthog/warehouse/api/external_data_schema.py:0: note: def get(self, Type, /) -> dict[str, list[IncrementalField]] | None
-posthog/warehouse/api/external_data_schema.py:0: note: def get(self, Type, dict[str, list[IncrementalField]], /) -> dict[str, list[IncrementalField]]
-posthog/warehouse/api/external_data_schema.py:0: note: def [_T] get(self, Type, _T, /) -> dict[str, list[IncrementalField]] | _T
-posthog/warehouse/api/table.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/warehouse/api/table.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/warehouse/api/table.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: error: No overload variant of "get" of "dict" matches argument types "str", "tuple[()]"  [call-overload]
-posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: Possible overload variants:
-posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: def get(self, Type, /) -> Sequence[str] | None
-posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: def get(self, Type, Sequence[str], /) -> Sequence[str]
-posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: def [_T] get(self, Type, _T, /) -> Sequence[str] | _T
-posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: error: Argument "source_id" to "sync_old_schemas_with_new_schemas" has incompatible type "str"; expected "UUID"  [arg-type]
+posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Invalid index type "str | None" for "dict[str, ndarray[Any, dtype[Any]]]"; expected type "str"  [index]
+posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Invalid index type "str | None" for "dict[str, ndarray[Any, dtype[Any]]]"; expected type "str"  [index]
+posthog/temporal/data_imports/pipelines/sql_database_v2/arrow_helpers.py:0: error: Invalid index type "str | None" for "dict[str, TColumnSchema]"; expected type "str"  [index]
 posthog/tasks/exports/test/test_csv_exporter.py:0: error: Function is missing a return type annotation  [no-untyped-def]
 posthog/tasks/exports/test/test_csv_exporter.py:0: error: Function is missing a type annotation  [no-untyped-def]
 posthog/tasks/exports/test/test_csv_exporter.py:0: error: Function is missing a type annotation for one or more arguments  [no-untyped-def]
@@ -664,7 +554,6 @@ posthog/queries/trends/test/test_person.py:0: error: Invalid index type "int" fo
 posthog/queries/trends/test/test_person.py:0: error: "str" has no attribute "get"  [attr-defined]
 posthog/queries/trends/test/test_person.py:0: error: Invalid index type "int" for "_MonkeyPatchedResponse"; expected type "str"  [index]
 posthog/models/test/test_organization_model.py:0: error: Module "django.utils.timezone" does not explicitly export attribute "timedelta"  [attr-defined]
-posthog/hogql_queries/test/test_actors_query_runner.py:0: error: Incompatible types in assignment (expression has type "Expr", variable has type "SelectQuery")  [assignment]
 posthog/hogql/test/test_resolver.py:0: error: Item "None" of "JoinExpr | None" has no attribute "next_join"  [union-attr]
 posthog/hogql/test/test_resolver.py:0: error: Item "None" of "JoinExpr | Any | None" has no attribute "constraint"  [union-attr]
 posthog/hogql/test/test_resolver.py:0: error: Item "None" of "JoinConstraint | Any | None" has no attribute "constraint_type"  [union-attr]
@@ -710,9 +599,6 @@ posthog/hogql/test/test_parser_python.py:0: error: Unsupported dynamic base clas
 posthog/hogql/test/test_parser_cpp.py:0: error: Unsupported dynamic base class "parser_test_factory"  [misc]
 posthog/hogql/test/test_parse_string_python.py:0: error: Unsupported dynamic base class "parse_string_test_factory"  [misc]
 posthog/hogql/test/test_parse_string_cpp.py:0: error: Unsupported dynamic base class "parse_string_test_factory"  [misc]
-posthog/hogql/functions/test/test_cohort.py:0: error: "TestCohort" has no attribute "snapshot"  [attr-defined]
-posthog/hogql/functions/test/test_cohort.py:0: error: "TestCohort" has no attribute "snapshot"  [attr-defined]
-posthog/hogql/functions/test/test_cohort.py:0: error: "TestCohort" has no attribute "snapshot"  [attr-defined]
 posthog/hogql/database/test/test_view.py:0: error: Argument "dialect" to "print_ast" has incompatible type "str"; expected "Literal['hogql', 'clickhouse']"  [arg-type]
 posthog/hogql/database/test/test_s3_table.py:0: error: Argument "dialect" to "print_ast" has incompatible type "str"; expected "Literal['hogql', 'clickhouse']"  [arg-type]
 posthog/helpers/full_text_search.py:0: error: Incompatible return value type (got "SearchVector", expected "CombinedExpression")  [return-value]
@@ -792,6 +678,22 @@ posthog/temporal/tests/batch_exports/test_batch_exports.py:0: error: TypedDict k
 posthog/temporal/data_modeling/run_workflow.py:0: error: Dict entry 20 has incompatible type "str": "Literal['complex']"; expected "str": "Literal['text', 'double', 'bool', 'timestamp', 'bigint', 'binary', 'json', 'decimal', 'wei', 'date', 'time']"  [dict-item]
 posthog/temporal/data_modeling/run_workflow.py:0: error: Dict entry 21 has incompatible type "str": "Literal['complex']"; expected "str": "Literal['text', 'double', 'bool', 'timestamp', 'bigint', 'binary', 'json', 'decimal', 'wei', 'date', 'time']"  [dict-item]
 posthog/temporal/data_modeling/run_workflow.py:0: error: Dict entry 22 has incompatible type "str": "Literal['complex']"; expected "str": "Literal['text', 'double', 'bool', 'timestamp', 'bigint', 'binary', 'json', 'decimal', 'wei', 'date', 'time']"  [dict-item]
+posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: error: No overload variant of "get" of "dict" matches argument types "str", "tuple[()]"  [call-overload]
+posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: Possible overload variants:
+posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: def get(self, Type, /) -> Sequence[str] | None
+posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: def get(self, Type, Sequence[str], /) -> Sequence[str]
+posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: note: def [_T] get(self, Type, _T, /) -> Sequence[str] | _T
+posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py:0: error: Argument "source_id" to "sync_old_schemas_with_new_schemas" has incompatible type "str"; expected "UUID"  [arg-type]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Item "None" of "Incremental[Any] | None" has no attribute "row_order"  [union-attr]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Incompatible types in assignment (expression has type "Literal['asc', 'desc'] | Any | None", variable has type "Literal['asc', 'desc']")  [assignment]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "Column[Any]")  [assignment]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "Literal['asc', 'desc']")  [assignment]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Item "None" of "dict[str, Any] | None" has no attribute "get"  [union-attr]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Argument "primary_key" to "make_hints" has incompatible type "list[str] | None"; expected "str | Sequence[str] | Callable[[Any], str | Sequence[str]]"  [arg-type]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/sql_database_v2/helpers.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/temporal/data_imports/pipelines/pipeline_sync.py:0: error: "FilesystemDestinationClientConfiguration" has no attribute "delta_jobs_per_write"  [attr-defined]
 posthog/temporal/data_imports/pipelines/pipeline_sync.py:0: error: "type[FilesystemDestinationClientConfiguration]" has no attribute "delta_jobs_per_write"  [attr-defined]
 posthog/temporal/data_imports/pipelines/pipeline_sync.py:0: error: Incompatible types in assignment (expression has type "object", variable has type "DataWarehouseCredential | Combinable | None")  [assignment]
@@ -824,6 +726,23 @@ posthog/temporal/tests/batch_exports/test_snowflake_batch_export_workflow.py:0:
 posthog/temporal/tests/batch_exports/test_snowflake_batch_export_workflow.py:0: error: Need type annotation for "_execute_async_calls" (hint: "_execute_async_calls: list[<type>] = ...")  [var-annotated]
 posthog/temporal/tests/batch_exports/test_snowflake_batch_export_workflow.py:0: error: Need type annotation for "_cursors" (hint: "_cursors: list[<type>] = ...")  [var-annotated]
 posthog/temporal/tests/batch_exports/test_snowflake_batch_export_workflow.py:0: error: List item 0 has incompatible type "tuple[str, str, int, int, int, int, str, int]"; expected "tuple[str, str, int, int, str, str, str, str]"  [list-item]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: error: No overload variant of "with_only_columns" of "Select" matches argument type "ReadOnlyColumnCollection[str, Column[Any]]"  [call-overload]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: Possible overload variants:
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], /) -> Select[tuple[_T0]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], /) -> Select[tuple[_T0, _T1]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], /) -> Select[tuple[_T0, _T1, _T2]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], /) -> Select[tuple[_T0, _T1, _T2, _T3]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4, _T5] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], TypedColumnsClauseRole[_T5] | SQLCoreOperations[_T5] | type[_T5], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4, _T5]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4, _T5, _T6] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], TypedColumnsClauseRole[_T5] | SQLCoreOperations[_T5] | type[_T5], TypedColumnsClauseRole[_T6] | SQLCoreOperations[_T6] | type[_T6], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7] with_only_columns(self, TypedColumnsClauseRole[_T0] | SQLCoreOperations[_T0] | type[_T0], TypedColumnsClauseRole[_T1] | SQLCoreOperations[_T1] | type[_T1], TypedColumnsClauseRole[_T2] | SQLCoreOperations[_T2] | type[_T2], TypedColumnsClauseRole[_T3] | SQLCoreOperations[_T3] | type[_T3], TypedColumnsClauseRole[_T4] | SQLCoreOperations[_T4] | type[_T4], TypedColumnsClauseRole[_T5] | SQLCoreOperations[_T5] | type[_T5], TypedColumnsClauseRole[_T6] | SQLCoreOperations[_T6] | type[_T6], TypedColumnsClauseRole[_T7] | SQLCoreOperations[_T7] | type[_T7], /) -> Select[tuple[_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def with_only_columns(self, *entities: TypedColumnsClauseRole[Any] | ColumnsClauseRole | SQLCoreOperations[Any] | Literal['*', 1] | type[Any] | Inspectable[_HasClauseElement[Any]] | _HasClauseElement[Any], maintain_column_froms: bool = ..., **Any) -> Select[Any]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: error: No overload variant of "resource" matches argument types "Callable[[Engine, Table, int, Literal['sqlalchemy', 'pyarrow', 'pandas', 'connectorx'], Incremental[Any] | None, bool, Callable[[Table], None] | None, Literal['minimal', 'full', 'full_with_precision'], dict[str, Any] | None, Callable[[TypeEngine[Any]], TypeEngine[Any] | type[TypeEngine[Any]] | None] | None, list[str] | None, Callable[[Select[Any], Table], Select[Any]] | None, list[str] | None], Iterator[Any]]", "str", "list[str] | None", "list[str] | None", "dict[str, TColumnSchema]", "Collection[str]", "str"  [call-overload]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: Possible overload variants:
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TResourceFunParams`-1, TDltResourceImpl: DltResource] resource(Callable[TResourceFunParams, Any], /, name: str = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ...) -> TDltResourceImpl
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TDltResourceImpl: DltResource] resource(None = ..., /, name: str = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ...) -> Callable[[Callable[TResourceFunParams, Any]], TDltResourceImpl]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TDltResourceImpl: DltResource] resource(None = ..., /, name: str | Callable[[Any], str] = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ..., standalone: Literal[True] = ...) -> Callable[[Callable[TResourceFunParams, Any]], Callable[TResourceFunParams, TDltResourceImpl]]
+posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py:0: note: def [TDltResourceImpl: DltResource] resource(list[Any] | tuple[Any] | Iterator[Any], /, name: str = ..., table_name: str | Callable[[Any], str] = ..., max_table_nesting: int = ..., write_disposition: Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict | Callable[[Any], Literal['skip', 'append', 'replace', 'merge'] | TWriteDispositionDict | TMergeDispositionDict | TScd2StrategyDict] = ..., columns: dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel] | Callable[[Any], dict[str, TColumnSchema] | Sequence[TColumnSchema] | BaseModel | type[BaseModel]] = ..., primary_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., merge_key: str | Sequence[str] | Callable[[Any], str | Sequence[str]] = ..., schema_contract: Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | Callable[[Any], Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict] = ..., table_format: Literal['iceberg', 'delta', 'hive'] | Callable[[Any], Literal['iceberg', 'delta', 'hive']] = ..., file_format: Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference'] | Callable[[Any], Literal['preferred', 'jsonl', 'typed-jsonl', 'insert_values', 'parquet', 'csv', 'reference']] = ..., references: Sequence[TTableReference] | Callable[[Any], Sequence[TTableReference]] = ..., selected: bool = ..., spec: type[BaseConfiguration] = ..., parallelized: bool = ..., _impl_cls: type[TDltResourceImpl] = ...) -> TDltResourceImpl
 posthog/migrations/0237_remove_timezone_from_teams.py:0: error: Argument 2 to "RunPython" has incompatible type "Callable[[Migration, Any], None]"; expected "_CodeCallable | None"  [arg-type]
 posthog/migrations/0228_fix_tile_layouts.py:0: error: Argument 2 to "RunPython" has incompatible type "Callable[[Migration, Any], None]"; expected "_CodeCallable | None"  [arg-type]
 posthog/api/plugin_log_entry.py:0: error: Name "timezone.datetime" is not defined  [name-defined]
@@ -831,22 +750,79 @@ posthog/api/plugin_log_entry.py:0: error: Module "django.utils.timezone" does no
 posthog/api/plugin_log_entry.py:0: error: Name "timezone.datetime" is not defined  [name-defined]
 posthog/api/plugin_log_entry.py:0: error: Module "django.utils.timezone" does not explicitly export attribute "datetime"  [attr-defined]
 posthog/temporal/tests/batch_exports/test_redshift_batch_export_workflow.py:0: error: Incompatible types in assignment (expression has type "str | int", variable has type "int")  [assignment]
-posthog/temporal/data_imports/external_data_job.py:0: error: Argument "status" to "update_external_job_status" has incompatible type "str"; expected "Status"  [arg-type]
 posthog/api/sharing.py:0: error: Item "None" of "list[Any] | None" has no attribute "__iter__" (not iterable)  [union-attr]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Dict entry 2 has incompatible type "Literal['auto']": "None"; expected "Literal['json_response', 'header_link', 'auto', 'single_page', 'cursor', 'offset', 'page_number']": "type[BasePaginator]"  [dict-item]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "None", variable has type "AuthConfigBase")  [assignment]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Argument 1 to "get_auth_class" has incompatible type "Literal['bearer', 'api_key', 'http_basic'] | None"; expected "Literal['bearer', 'api_key', 'http_basic']"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Need type annotation for "dependency_graph"  [var-annotated]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "None", target has type "ResolvedParam")  [assignment]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible return value type (got "tuple[TopologicalSorter[Any], dict[str, EndpointResource], dict[str, ResolvedParam]]", expected "tuple[Any, dict[str, EndpointResource], dict[str, ResolvedParam | None]]")  [return-value]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unsupported right operand type for in ("str | Endpoint | None")  [operator]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Value of type variable "StrOrLiteralStr" of "parse" of "Formatter" cannot be "str | None"  [type-var]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unsupported right operand type for in ("dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None")  [operator]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unsupported right operand type for in ("dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None")  [operator]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Value of type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" is not indexable  [index]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Item "None" of "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" has no attribute "pop"  [union-attr]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Value of type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" is not indexable  [index]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Item "None" of "str | None" has no attribute "format"  [union-attr]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Argument 1 to "single_entity_path" has incompatible type "str | None"; expected "str"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Item "None" of "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None" has no attribute "items"  [union-attr]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "str | None", variable has type "str")  [assignment]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Incompatible types in assignment (expression has type "str | None", variable has type "str")  [assignment]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Statement is unreachable  [unreachable]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 0 has incompatible type "dict[str, Any] | None"; expected "SupportsKeysAndGetItem[str, Any]"  [dict-item]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 1 has incompatible type "dict[str, Any] | None"; expected "SupportsKeysAndGetItem[str, Any]"  [dict-item]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 0 has incompatible type "dict[str, Any] | None"; expected "SupportsKeysAndGetItem[str, ResolveParamConfig | IncrementalParamConfig | Any]"  [dict-item]
+posthog/temporal/data_imports/pipelines/rest_source/config_setup.py:0: error: Unpacked dict entry 1 has incompatible type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None"; expected "SupportsKeysAndGetItem[str, ResolveParamConfig | IncrementalParamConfig | Any]"  [dict-item]
 posthog/api/test/batch_exports/conftest.py:0: error: Signature of "run" incompatible with supertype "Worker"  [override]
 posthog/api/test/batch_exports/conftest.py:0: note: Superclass:
 posthog/api/test/batch_exports/conftest.py:0: note: def run(self) -> Coroutine[Any, Any, None]
 posthog/api/test/batch_exports/conftest.py:0: note: Subclass:
 posthog/api/test/batch_exports/conftest.py:0: note: def run(self, loop: Any) -> Any
 posthog/api/test/batch_exports/conftest.py:0: error: Argument "activities" to "ThreadedWorker" has incompatible type "list[function]"; expected "Sequence[Callable[..., Any]]"  [arg-type]
-posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
-posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
-posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
-posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
-posthog/temporal/tests/data_imports/test_end_to_end.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Not all union combinations were tried because there are too many unions  [misc]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 2 to "source" has incompatible type "str | None"; expected "str"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 3 to "source" has incompatible type "str | None"; expected "str"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 4 to "source" has incompatible type "int | None"; expected "int"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 6 to "source" has incompatible type "Schema | None"; expected "Schema"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 7 to "source" has incompatible type "Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict | None"; expected "Literal['evolve', 'discard_value', 'freeze', 'discard_row'] | TSchemaContractDict"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 8 to "source" has incompatible type "type[BaseConfiguration] | None"; expected "type[BaseConfiguration]"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 1 to "build_resource_dependency_graph" has incompatible type "EndpointResourceBase | None"; expected "EndpointResourceBase"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Incompatible types in assignment (expression has type "list[str] | None", variable has type "list[str]")  [assignment]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 1 to "setup_incremental_object" has incompatible type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None"; expected "dict[str, Any]"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument "base_url" to "RESTClient" has incompatible type "str | None"; expected "str"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Argument 1 to "exclude_keys" has incompatible type "dict[str, ResolveParamConfig | IncrementalParamConfig | Any] | None"; expected "Mapping[str, Any]"  [arg-type]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Incompatible default for argument "resolved_param" (default has type "ResolvedParam | None", argument has type "ResolvedParam")  [assignment]
+posthog/temporal/data_imports/pipelines/rest_source/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/api/test/test_team.py:0: error: "HttpResponse" has no attribute "json"  [attr-defined]
 posthog/api/test/test_team.py:0: error: "HttpResponse" has no attribute "json"  [attr-defined]
 posthog/test/test_middleware.py:0: error: Incompatible types in assignment (expression has type "_MonkeyPatchedWSGIResponse", variable has type "_MonkeyPatchedResponse")  [assignment]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/zendesk/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/vitally/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/pipelines/stripe/__init__.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/management/commands/test/test_create_batch_export_from_app.py:0: error: Incompatible return value type (got "dict[str, Collection[str]]", expected "dict[str, str]")  [return-value]
 posthog/management/commands/test/test_create_batch_export_from_app.py:0: error: Incompatible types in assignment (expression has type "dict[str, Collection[str]]", variable has type "dict[str, str]")  [assignment]
 posthog/management/commands/test/test_create_batch_export_from_app.py:0: error: Unpacked dict entry 1 has incompatible type "str"; expected "SupportsKeysAndGetItem[str, str]"  [dict-item]
@@ -888,6 +864,22 @@ posthog/api/test/batch_exports/test_update.py:0: error: Value of type "BatchExpo
 posthog/api/test/batch_exports/test_update.py:0: error: Value of type "BatchExport" is not indexable  [index]
 posthog/api/test/batch_exports/test_update.py:0: error: Value of type "BatchExport" is not indexable  [index]
 posthog/api/test/batch_exports/test_pause.py:0: error: "batch_export_delete_schedule" does not return a value (it only ever returns None)  [func-returns-value]
+posthog/warehouse/api/external_data_schema.py:0: error: Incompatible return value type (got "str | None", expected "SyncType | None")  [return-value]
+posthog/warehouse/api/external_data_schema.py:0: error: Argument 1 to "get_sql_schemas_for_source_type" has incompatible type "str"; expected "Type"  [arg-type]
+posthog/warehouse/api/external_data_schema.py:0: error: No overload variant of "get" of "dict" matches argument type "str"  [call-overload]
+posthog/warehouse/api/external_data_schema.py:0: note: Possible overload variants:
+posthog/warehouse/api/external_data_schema.py:0: note: def get(self, Type, /) -> dict[str, list[IncrementalField]] | None
+posthog/warehouse/api/external_data_schema.py:0: note: def get(self, Type, dict[str, list[IncrementalField]], /) -> dict[str, list[IncrementalField]]
+posthog/warehouse/api/external_data_schema.py:0: note: def [_T] get(self, Type, _T, /) -> dict[str, list[IncrementalField]] | _T
+posthog/warehouse/api/table.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/warehouse/api/table.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/warehouse/api/table.py:0: error: Unused "type: ignore" comment  [unused-ignore]
+posthog/temporal/data_imports/external_data_job.py:0: error: Argument "status" to "update_external_job_status" has incompatible type "str"; expected "Status"  [arg-type]
+posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
+posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
+posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
+posthog/temporal/tests/external_data/test_external_data_job.py:0: error: Invalid index type "str" for "dict[Type, Sequence[str]]"; expected type "Type"  [index]
+posthog/temporal/tests/data_imports/test_end_to_end.py:0: error: Unused "type: ignore" comment  [unused-ignore]
 posthog/api/query.py:0: error: Statement is unreachable  [unreachable]
 posthog/api/test/test_capture.py:0: error: Statement is unreachable  [unreachable]
 posthog/api/test/test_capture.py:0: error: Incompatible return value type (got "_MonkeyPatchedWSGIResponse", expected "HttpResponse")  [return-value]
diff --git a/package.json b/package.json
index fc88d73076ccf..595a183f78603 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
         "prettier": "prettier --write \"./**/*.{js,mjs,ts,tsx,json,yaml,yml,css,scss}\"",
         "prettier:check": "prettier --check \"frontend/**/*.{js,mjs,ts,tsx,json,yaml,yml,css,scss}\"",
         "typescript:check": "tsc --noEmit && echo \"No errors reported by tsc.\"",
-        "lint:js": "eslint frontend/src cypress",
+        "lint:js": "eslint --cache frontend/src cypress",
         "lint:css": "stylelint \"frontend/**/*.{css,scss}\"",
         "format:backend": "ruff .",
         "format:frontend": "pnpm lint:js --fix && pnpm lint:css --fix && pnpm prettier",
@@ -77,7 +77,7 @@
         "@microlink/react-json-view": "^1.21.3",
         "@microsoft/fetch-event-source": "^2.0.1",
         "@monaco-editor/react": "4.6.0",
-        "@posthog/hogvm": "^1.0.61",
+        "@posthog/hogvm": "^1.0.64",
         "@posthog/icons": "0.9.2",
         "@posthog/plugin-scaffold": "^1.4.4",
         "@react-hook/size": "^2.1.2",
@@ -132,6 +132,7 @@
         "expr-eval": "^2.0.2",
         "express": "^4.17.1",
         "fast-deep-equal": "^3.1.3",
+        "fastpriorityqueue": "^0.7.5",
         "fflate": "^0.7.4",
         "fs-extra": "^10.0.0",
         "fuse.js": "^6.6.2",
@@ -160,7 +161,7 @@
         "pmtiles": "^2.11.0",
         "postcss": "^8.4.31",
         "postcss-preset-env": "^9.3.0",
-        "posthog-js": "1.194.3",
+        "posthog-js": "1.201.1",
         "posthog-js-lite": "3.0.0",
         "prettier": "^2.8.8",
         "prop-types": "^15.7.2",
@@ -264,6 +265,7 @@
         "axe-core": "^4.4.3",
         "babel-loader": "^8.0.6",
         "babel-plugin-import": "^1.13.0",
+        "caniuse-lite": "^1.0.30001687",
         "concurrently": "^5.3.0",
         "css-loader": "^3.4.2",
         "cypress": "^13.11.0",
@@ -348,7 +350,7 @@
             "prettier --write"
         ],
         "frontend/src/**/*.{js,jsx,mjs,ts,tsx}": [
-            "eslint -c .eslintrc.js --fix",
+            "eslint --cache -c .eslintrc.js --fix",
             "prettier --write"
         ],
         "frontend/*.mjs": [
@@ -375,7 +377,7 @@
             "last 2 edge versions"
         ],
         "production": [
-            "defaults and not not op_mini all"
+            "defaults and not op_mini all"
         ]
     },
     "browser": {
diff --git a/plugin-server/package.json b/plugin-server/package.json
index 3699ce1bbc769..4878a53cef9a4 100644
--- a/plugin-server/package.json
+++ b/plugin-server/package.json
@@ -42,8 +42,8 @@
     "repository": "https://github.com/PostHog/posthog-plugin-server",
     "license": "MIT",
     "dependencies": {
-        "@aws-sdk/client-s3": "^3.315.0",
-        "@aws-sdk/lib-storage": "^3.315.0",
+        "@aws-sdk/client-s3": "^3.709.0",
+        "@aws-sdk/lib-storage": "^3.709.0",
         "@babel/core": "^7.18.10",
         "@babel/plugin-transform-react-jsx": "^7.18.10",
         "@babel/preset-env": "^7.18.10",
@@ -54,7 +54,7 @@
         "@maxmind/geoip2-node": "^3.4.0",
         "@posthog/clickhouse": "^1.7.0",
         "@posthog/cyclotron": "file:../rust/cyclotron-node",
-        "@posthog/hogvm": "^1.0.61",
+        "@posthog/hogvm": "^1.0.64",
         "@posthog/plugin-scaffold": "1.4.4",
         "@sentry/node": "^7.49.0",
         "@sentry/profiling-node": "^0.3.0",
diff --git a/plugin-server/pnpm-lock.yaml b/plugin-server/pnpm-lock.yaml
index e49da8ba13491..944b81ab2a4c9 100644
--- a/plugin-server/pnpm-lock.yaml
+++ b/plugin-server/pnpm-lock.yaml
@@ -11,11 +11,11 @@ patchedDependencies:
 
 dependencies:
   '@aws-sdk/client-s3':
-    specifier: ^3.315.0
-    version: 3.319.0
+    specifier: ^3.709.0
+    version: 3.709.0
   '@aws-sdk/lib-storage':
-    specifier: ^3.315.0
-    version: 3.319.0(@aws-sdk/abort-controller@3.374.0)(@aws-sdk/client-s3@3.319.0)
+    specifier: ^3.709.0
+    version: 3.709.0(@aws-sdk/client-s3@3.709.0)
   '@babel/core':
     specifier: ^7.18.10
     version: 7.21.4
@@ -47,8 +47,8 @@ dependencies:
     specifier: file:../rust/cyclotron-node
     version: file:../rust/cyclotron-node
   '@posthog/hogvm':
-    specifier: ^1.0.61
-    version: 1.0.61(luxon@3.4.4)
+    specifier: ^1.0.64
+    version: 1.0.64(luxon@3.4.4)
   '@posthog/plugin-scaffold':
     specifier: 1.4.4
     version: 1.4.4
@@ -355,979 +355,651 @@ packages:
       '@jridgewell/gen-mapping': 0.3.3
       '@jridgewell/trace-mapping': 0.3.18
 
-  /@aws-crypto/crc32@3.0.0:
-    resolution: {integrity: sha512-IzSgsrxUcsrejQbPVilIKy16kAT52EwB6zSaI+M3xxIhKh5+aldEyvI+z6erM7TCLB2BJsFrtHjp6/4/sr+3dA==}
+  /@aws-crypto/crc32@5.2.0:
+    resolution: {integrity: sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-crypto/util': 3.0.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 1.14.1
-    dev: false
-
-  /@aws-crypto/crc32c@3.0.0:
-    resolution: {integrity: sha512-ENNPPManmnVJ4BTXlOjAgD7URidbAznURqD0KvfREyc4o20DPYdEldU1f5cQ7Jbj0CJJSPaMIk/9ZshdB3210w==}
-    dependencies:
-      '@aws-crypto/util': 3.0.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 1.14.1
+      '@aws-crypto/util': 5.2.0
+      '@aws-sdk/types': 3.709.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-crypto/ie11-detection@3.0.0:
-    resolution: {integrity: sha512-341lBBkiY1DfDNKai/wXM3aujNBkXR7tq1URPQDL9wi3AUbI80NR74uF1TXHMm7po1AcnFk8iu2S2IeU/+/A+Q==}
+  /@aws-crypto/crc32c@5.2.0:
+    resolution: {integrity: sha512-+iWb8qaHLYKrNvGRbiYRHSdKRWhto5XlZUEBwDjYNf+ly5SVYG6zEoYIdxvf5R3zyeP16w4PLBn3rH1xc74Rag==}
     dependencies:
-      tslib: 1.14.1
+      '@aws-crypto/util': 5.2.0
+      '@aws-sdk/types': 3.709.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-crypto/sha1-browser@3.0.0:
-    resolution: {integrity: sha512-NJth5c997GLHs6nOYTzFKTbYdMNA6/1XlKVgnZoaZcQ7z7UJlOgj2JdbHE8tiYLS3fzXNCguct77SPGat2raSw==}
+  /@aws-crypto/sha1-browser@5.2.0:
+    resolution: {integrity: sha512-OH6lveCFfcDjX4dbAvCFSYUjJZjDr/3XJ3xHtjn3Oj5b9RjojQo8npoLeA/bNwkOkrSQ0wgrHzXk4tDRxGKJeg==}
     dependencies:
-      '@aws-crypto/ie11-detection': 3.0.0
-      '@aws-crypto/supports-web-crypto': 3.0.0
-      '@aws-crypto/util': 3.0.0
-      '@aws-sdk/types': 3.310.0
+      '@aws-crypto/supports-web-crypto': 5.2.0
+      '@aws-crypto/util': 5.2.0
+      '@aws-sdk/types': 3.709.0
       '@aws-sdk/util-locate-window': 3.310.0
-      '@aws-sdk/util-utf8-browser': 3.259.0
-      tslib: 1.14.1
+      '@smithy/util-utf8': 2.3.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-crypto/sha256-browser@3.0.0:
-    resolution: {integrity: sha512-8VLmW2B+gjFbU5uMeqtQM6Nj0/F1bro80xQXCW6CQBWgosFWXTx77aeOF5CAIAmbOK64SdMBJdNr6J41yP5mvQ==}
+  /@aws-crypto/sha256-browser@5.2.0:
+    resolution: {integrity: sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==}
     dependencies:
-      '@aws-crypto/ie11-detection': 3.0.0
-      '@aws-crypto/sha256-js': 3.0.0
-      '@aws-crypto/supports-web-crypto': 3.0.0
-      '@aws-crypto/util': 3.0.0
-      '@aws-sdk/types': 3.310.0
+      '@aws-crypto/sha256-js': 5.2.0
+      '@aws-crypto/supports-web-crypto': 5.2.0
+      '@aws-crypto/util': 5.2.0
+      '@aws-sdk/types': 3.709.0
       '@aws-sdk/util-locate-window': 3.310.0
-      '@aws-sdk/util-utf8-browser': 3.259.0
-      tslib: 1.14.1
-    dev: false
-
-  /@aws-crypto/sha256-js@3.0.0:
-    resolution: {integrity: sha512-PnNN7os0+yd1XvXAy23CFOmTbMaDxgxXtTKHybrJ39Y8kGzBATgBFibWJKH6BhytLI/Zyszs87xCOBNyBig6vQ==}
-    dependencies:
-      '@aws-crypto/util': 3.0.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 1.14.1
-    dev: false
-
-  /@aws-crypto/supports-web-crypto@3.0.0:
-    resolution: {integrity: sha512-06hBdMwUAb2WFTuGG73LSC0wfPu93xWwo5vL2et9eymgmu3Id5vFAHBbajVWiGhPO37qcsdCap/FqXvJGJWPIg==}
-    dependencies:
-      tslib: 1.14.1
-    dev: false
-
-  /@aws-crypto/util@3.0.0:
-    resolution: {integrity: sha512-2OJlpeJpCR48CC8r+uKVChzs9Iungj9wkZrl8Z041DWEWvyIHILYKCPNzJghKsivj+S3mLo6BVc7mBNzdxA46w==}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-utf8-browser': 3.259.0
-      tslib: 1.14.1
+      '@smithy/util-utf8': 2.3.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/abort-controller@3.310.0:
-    resolution: {integrity: sha512-v1zrRQxDLA1MdPim159Vx/CPHqsB4uybSxRi1CnfHO5ZjHryx3a5htW2gdGAykVCul40+yJXvfpufMrELVxH+g==}
-    engines: {node: '>=14.0.0'}
+  /@aws-crypto/sha256-js@5.2.0:
+    resolution: {integrity: sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-crypto/util': 5.2.0
+      '@aws-sdk/types': 3.709.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/abort-controller@3.374.0:
-    resolution: {integrity: sha512-pO1pqFBdIF28ZvnJmg58Erj35RLzXsTrjvHghdc/xgtSvodFFCNrUsPg6AP3On8eiw9elpHoS4P8jMx1pHDXEw==}
-    engines: {node: '>=14.0.0'}
-    deprecated: This package has moved to @smithy/abort-controller
+  /@aws-crypto/supports-web-crypto@5.2.0:
+    resolution: {integrity: sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg==}
     dependencies:
-      '@smithy/abort-controller': 1.1.0
       tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/chunked-blob-reader@3.310.0:
-    resolution: {integrity: sha512-CrJS3exo4mWaLnWxfCH+w88Ou0IcAZSIkk4QbmxiHl/5Dq705OLoxf4385MVyExpqpeVJYOYQ2WaD8i/pQZ2fg==}
+  /@aws-crypto/util@5.2.0:
+    resolution: {integrity: sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==}
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/util-utf8': 2.3.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/client-s3@3.319.0:
-    resolution: {integrity: sha512-/XzElEO4iZTBgvrcWq20sxKLvhRetjT1gOPRF4Ra2iSCbeVIT/feYdEaSSgMsaiqrREywBc+59NiOyxImWTaOA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-crypto/sha1-browser': 3.0.0
-      '@aws-crypto/sha256-browser': 3.0.0
-      '@aws-crypto/sha256-js': 3.0.0
-      '@aws-sdk/client-sts': 3.319.0
-      '@aws-sdk/config-resolver': 3.310.0
-      '@aws-sdk/credential-provider-node': 3.319.0
-      '@aws-sdk/eventstream-serde-browser': 3.310.0
-      '@aws-sdk/eventstream-serde-config-resolver': 3.310.0
-      '@aws-sdk/eventstream-serde-node': 3.310.0
-      '@aws-sdk/fetch-http-handler': 3.310.0
-      '@aws-sdk/hash-blob-browser': 3.310.0
-      '@aws-sdk/hash-node': 3.310.0
-      '@aws-sdk/hash-stream-node': 3.310.0
-      '@aws-sdk/invalid-dependency': 3.310.0
-      '@aws-sdk/md5-js': 3.310.0
-      '@aws-sdk/middleware-bucket-endpoint': 3.310.0
-      '@aws-sdk/middleware-content-length': 3.310.0
-      '@aws-sdk/middleware-endpoint': 3.310.0
-      '@aws-sdk/middleware-expect-continue': 3.310.0
-      '@aws-sdk/middleware-flexible-checksums': 3.310.0
-      '@aws-sdk/middleware-host-header': 3.310.0
-      '@aws-sdk/middleware-location-constraint': 3.310.0
-      '@aws-sdk/middleware-logger': 3.310.0
-      '@aws-sdk/middleware-recursion-detection': 3.310.0
-      '@aws-sdk/middleware-retry': 3.310.0
-      '@aws-sdk/middleware-sdk-s3': 3.310.0
-      '@aws-sdk/middleware-serde': 3.310.0
-      '@aws-sdk/middleware-signing': 3.310.0
-      '@aws-sdk/middleware-ssec': 3.310.0
-      '@aws-sdk/middleware-stack': 3.310.0
-      '@aws-sdk/middleware-user-agent': 3.319.0
-      '@aws-sdk/node-config-provider': 3.310.0
-      '@aws-sdk/node-http-handler': 3.310.0
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/signature-v4-multi-region': 3.310.0
-      '@aws-sdk/smithy-client': 3.316.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/url-parser': 3.310.0
-      '@aws-sdk/util-base64': 3.310.0
-      '@aws-sdk/util-body-length-browser': 3.310.0
-      '@aws-sdk/util-body-length-node': 3.310.0
-      '@aws-sdk/util-defaults-mode-browser': 3.316.0
-      '@aws-sdk/util-defaults-mode-node': 3.316.0
-      '@aws-sdk/util-endpoints': 3.319.0
-      '@aws-sdk/util-retry': 3.310.0
-      '@aws-sdk/util-stream-browser': 3.310.0
-      '@aws-sdk/util-stream-node': 3.310.0
-      '@aws-sdk/util-user-agent-browser': 3.310.0
-      '@aws-sdk/util-user-agent-node': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      '@aws-sdk/util-waiter': 3.310.0
-      '@aws-sdk/xml-builder': 3.310.0
-      fast-xml-parser: 4.1.2
-      tslib: 2.5.0
+  /@aws-sdk/client-s3@3.709.0:
+    resolution: {integrity: sha512-IvC7coELoQ4YenTdULArVdL5yk6jNRVUALX1aqv9JlPdrXxb3Om6YrM9e7AlSTLxrULTsAe1ubm8i/DmcSY/Ng==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@aws-crypto/sha1-browser': 5.2.0
+      '@aws-crypto/sha256-browser': 5.2.0
+      '@aws-crypto/sha256-js': 5.2.0
+      '@aws-sdk/client-sso-oidc': 3.709.0(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/client-sts': 3.709.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/credential-provider-node': 3.709.0(@aws-sdk/client-sso-oidc@3.709.0)(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/middleware-bucket-endpoint': 3.709.0
+      '@aws-sdk/middleware-expect-continue': 3.709.0
+      '@aws-sdk/middleware-flexible-checksums': 3.709.0
+      '@aws-sdk/middleware-host-header': 3.709.0
+      '@aws-sdk/middleware-location-constraint': 3.709.0
+      '@aws-sdk/middleware-logger': 3.709.0
+      '@aws-sdk/middleware-recursion-detection': 3.709.0
+      '@aws-sdk/middleware-sdk-s3': 3.709.0
+      '@aws-sdk/middleware-ssec': 3.709.0
+      '@aws-sdk/middleware-user-agent': 3.709.0
+      '@aws-sdk/region-config-resolver': 3.709.0
+      '@aws-sdk/signature-v4-multi-region': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@aws-sdk/util-endpoints': 3.709.0
+      '@aws-sdk/util-user-agent-browser': 3.709.0
+      '@aws-sdk/util-user-agent-node': 3.709.0
+      '@aws-sdk/xml-builder': 3.709.0
+      '@smithy/config-resolver': 3.0.13
+      '@smithy/core': 2.5.5
+      '@smithy/eventstream-serde-browser': 3.0.14
+      '@smithy/eventstream-serde-config-resolver': 3.0.11
+      '@smithy/eventstream-serde-node': 3.0.13
+      '@smithy/fetch-http-handler': 4.1.2
+      '@smithy/hash-blob-browser': 3.1.10
+      '@smithy/hash-node': 3.0.11
+      '@smithy/hash-stream-node': 3.1.10
+      '@smithy/invalid-dependency': 3.0.11
+      '@smithy/md5-js': 3.0.11
+      '@smithy/middleware-content-length': 3.0.13
+      '@smithy/middleware-endpoint': 3.2.5
+      '@smithy/middleware-retry': 3.0.30
+      '@smithy/middleware-serde': 3.0.11
+      '@smithy/middleware-stack': 3.0.11
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/node-http-handler': 3.3.2
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/url-parser': 3.0.11
+      '@smithy/util-base64': 3.0.0
+      '@smithy/util-body-length-browser': 3.0.0
+      '@smithy/util-body-length-node': 3.0.0
+      '@smithy/util-defaults-mode-browser': 3.0.30
+      '@smithy/util-defaults-mode-node': 3.0.30
+      '@smithy/util-endpoints': 2.1.7
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-retry': 3.0.11
+      '@smithy/util-stream': 3.3.2
+      '@smithy/util-utf8': 3.0.0
+      '@smithy/util-waiter': 3.2.0
+      tslib: 2.6.2
     transitivePeerDependencies:
-      - '@aws-sdk/signature-v4-crt'
       - aws-crt
     dev: false
 
-  /@aws-sdk/client-sso-oidc@3.319.0:
-    resolution: {integrity: sha512-GJBgT/tephRZY3oTbDBMv+G9taoqKUIvGPn+7shmzz2P1SerutsRSfKfDXV+VptPNRoGmjjCLPmWjMFYbFKILQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-crypto/sha256-browser': 3.0.0
-      '@aws-crypto/sha256-js': 3.0.0
-      '@aws-sdk/config-resolver': 3.310.0
-      '@aws-sdk/fetch-http-handler': 3.310.0
-      '@aws-sdk/hash-node': 3.310.0
-      '@aws-sdk/invalid-dependency': 3.310.0
-      '@aws-sdk/middleware-content-length': 3.310.0
-      '@aws-sdk/middleware-endpoint': 3.310.0
-      '@aws-sdk/middleware-host-header': 3.310.0
-      '@aws-sdk/middleware-logger': 3.310.0
-      '@aws-sdk/middleware-recursion-detection': 3.310.0
-      '@aws-sdk/middleware-retry': 3.310.0
-      '@aws-sdk/middleware-serde': 3.310.0
-      '@aws-sdk/middleware-stack': 3.310.0
-      '@aws-sdk/middleware-user-agent': 3.319.0
-      '@aws-sdk/node-config-provider': 3.310.0
-      '@aws-sdk/node-http-handler': 3.310.0
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/smithy-client': 3.316.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/url-parser': 3.310.0
-      '@aws-sdk/util-base64': 3.310.0
-      '@aws-sdk/util-body-length-browser': 3.310.0
-      '@aws-sdk/util-body-length-node': 3.310.0
-      '@aws-sdk/util-defaults-mode-browser': 3.316.0
-      '@aws-sdk/util-defaults-mode-node': 3.316.0
-      '@aws-sdk/util-endpoints': 3.319.0
-      '@aws-sdk/util-retry': 3.310.0
-      '@aws-sdk/util-user-agent-browser': 3.310.0
-      '@aws-sdk/util-user-agent-node': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
+  /@aws-sdk/client-sso-oidc@3.709.0(@aws-sdk/client-sts@3.709.0):
+    resolution: {integrity: sha512-1w6egz17QQy661lNCRmZZlqIANEbD6g2VFAQIJbVwSiu7brg+GUns+mT1eLLLHAMQc1sL0Ds8/ybSK2SrgGgIA==}
+    engines: {node: '>=16.0.0'}
+    peerDependencies:
+      '@aws-sdk/client-sts': ^3.709.0
+    dependencies:
+      '@aws-crypto/sha256-browser': 5.2.0
+      '@aws-crypto/sha256-js': 5.2.0
+      '@aws-sdk/client-sts': 3.709.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/credential-provider-node': 3.709.0(@aws-sdk/client-sso-oidc@3.709.0)(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/middleware-host-header': 3.709.0
+      '@aws-sdk/middleware-logger': 3.709.0
+      '@aws-sdk/middleware-recursion-detection': 3.709.0
+      '@aws-sdk/middleware-user-agent': 3.709.0
+      '@aws-sdk/region-config-resolver': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@aws-sdk/util-endpoints': 3.709.0
+      '@aws-sdk/util-user-agent-browser': 3.709.0
+      '@aws-sdk/util-user-agent-node': 3.709.0
+      '@smithy/config-resolver': 3.0.13
+      '@smithy/core': 2.5.5
+      '@smithy/fetch-http-handler': 4.1.2
+      '@smithy/hash-node': 3.0.11
+      '@smithy/invalid-dependency': 3.0.11
+      '@smithy/middleware-content-length': 3.0.13
+      '@smithy/middleware-endpoint': 3.2.5
+      '@smithy/middleware-retry': 3.0.30
+      '@smithy/middleware-serde': 3.0.11
+      '@smithy/middleware-stack': 3.0.11
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/node-http-handler': 3.3.2
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/url-parser': 3.0.11
+      '@smithy/util-base64': 3.0.0
+      '@smithy/util-body-length-browser': 3.0.0
+      '@smithy/util-body-length-node': 3.0.0
+      '@smithy/util-defaults-mode-browser': 3.0.30
+      '@smithy/util-defaults-mode-node': 3.0.30
+      '@smithy/util-endpoints': 2.1.7
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-retry': 3.0.11
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
 
-  /@aws-sdk/client-sso@3.319.0:
-    resolution: {integrity: sha512-g46KgAjRiYBS8Oi85DPwSAQpt+Hgmw/YFgGVwZqMfTL70KNJwLFKRa5D9UocQd7t7OjPRdKF7g0Gp5peyAK9dw==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-crypto/sha256-browser': 3.0.0
-      '@aws-crypto/sha256-js': 3.0.0
-      '@aws-sdk/config-resolver': 3.310.0
-      '@aws-sdk/fetch-http-handler': 3.310.0
-      '@aws-sdk/hash-node': 3.310.0
-      '@aws-sdk/invalid-dependency': 3.310.0
-      '@aws-sdk/middleware-content-length': 3.310.0
-      '@aws-sdk/middleware-endpoint': 3.310.0
-      '@aws-sdk/middleware-host-header': 3.310.0
-      '@aws-sdk/middleware-logger': 3.310.0
-      '@aws-sdk/middleware-recursion-detection': 3.310.0
-      '@aws-sdk/middleware-retry': 3.310.0
-      '@aws-sdk/middleware-serde': 3.310.0
-      '@aws-sdk/middleware-stack': 3.310.0
-      '@aws-sdk/middleware-user-agent': 3.319.0
-      '@aws-sdk/node-config-provider': 3.310.0
-      '@aws-sdk/node-http-handler': 3.310.0
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/smithy-client': 3.316.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/url-parser': 3.310.0
-      '@aws-sdk/util-base64': 3.310.0
-      '@aws-sdk/util-body-length-browser': 3.310.0
-      '@aws-sdk/util-body-length-node': 3.310.0
-      '@aws-sdk/util-defaults-mode-browser': 3.316.0
-      '@aws-sdk/util-defaults-mode-node': 3.316.0
-      '@aws-sdk/util-endpoints': 3.319.0
-      '@aws-sdk/util-retry': 3.310.0
-      '@aws-sdk/util-user-agent-browser': 3.310.0
-      '@aws-sdk/util-user-agent-node': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
+  /@aws-sdk/client-sso@3.709.0:
+    resolution: {integrity: sha512-Qxeo8cN0jNy6Wnbqq4wucffAGJM6sJjofoTgNtPA6cC7sPYx7aYC6OAAAo6NaMRY+WywOKdS9Wgjx2QYRxKx7w==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@aws-crypto/sha256-browser': 5.2.0
+      '@aws-crypto/sha256-js': 5.2.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/middleware-host-header': 3.709.0
+      '@aws-sdk/middleware-logger': 3.709.0
+      '@aws-sdk/middleware-recursion-detection': 3.709.0
+      '@aws-sdk/middleware-user-agent': 3.709.0
+      '@aws-sdk/region-config-resolver': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@aws-sdk/util-endpoints': 3.709.0
+      '@aws-sdk/util-user-agent-browser': 3.709.0
+      '@aws-sdk/util-user-agent-node': 3.709.0
+      '@smithy/config-resolver': 3.0.13
+      '@smithy/core': 2.5.5
+      '@smithy/fetch-http-handler': 4.1.2
+      '@smithy/hash-node': 3.0.11
+      '@smithy/invalid-dependency': 3.0.11
+      '@smithy/middleware-content-length': 3.0.13
+      '@smithy/middleware-endpoint': 3.2.5
+      '@smithy/middleware-retry': 3.0.30
+      '@smithy/middleware-serde': 3.0.11
+      '@smithy/middleware-stack': 3.0.11
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/node-http-handler': 3.3.2
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/url-parser': 3.0.11
+      '@smithy/util-base64': 3.0.0
+      '@smithy/util-body-length-browser': 3.0.0
+      '@smithy/util-body-length-node': 3.0.0
+      '@smithy/util-defaults-mode-browser': 3.0.30
+      '@smithy/util-defaults-mode-node': 3.0.30
+      '@smithy/util-endpoints': 2.1.7
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-retry': 3.0.11
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
 
-  /@aws-sdk/client-sts@3.319.0:
-    resolution: {integrity: sha512-PRGGKCSKtyM3x629J9j4DMsH1cQT8UGW+R67u9Q5HrMK05gfjpmg+X1DQ3pgve4D8MI4R/Cm3NkYl2eUTbQHQg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-crypto/sha256-browser': 3.0.0
-      '@aws-crypto/sha256-js': 3.0.0
-      '@aws-sdk/config-resolver': 3.310.0
-      '@aws-sdk/credential-provider-node': 3.319.0
-      '@aws-sdk/fetch-http-handler': 3.310.0
-      '@aws-sdk/hash-node': 3.310.0
-      '@aws-sdk/invalid-dependency': 3.310.0
-      '@aws-sdk/middleware-content-length': 3.310.0
-      '@aws-sdk/middleware-endpoint': 3.310.0
-      '@aws-sdk/middleware-host-header': 3.310.0
-      '@aws-sdk/middleware-logger': 3.310.0
-      '@aws-sdk/middleware-recursion-detection': 3.310.0
-      '@aws-sdk/middleware-retry': 3.310.0
-      '@aws-sdk/middleware-sdk-sts': 3.310.0
-      '@aws-sdk/middleware-serde': 3.310.0
-      '@aws-sdk/middleware-signing': 3.310.0
-      '@aws-sdk/middleware-stack': 3.310.0
-      '@aws-sdk/middleware-user-agent': 3.319.0
-      '@aws-sdk/node-config-provider': 3.310.0
-      '@aws-sdk/node-http-handler': 3.310.0
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/smithy-client': 3.316.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/url-parser': 3.310.0
-      '@aws-sdk/util-base64': 3.310.0
-      '@aws-sdk/util-body-length-browser': 3.310.0
-      '@aws-sdk/util-body-length-node': 3.310.0
-      '@aws-sdk/util-defaults-mode-browser': 3.316.0
-      '@aws-sdk/util-defaults-mode-node': 3.316.0
-      '@aws-sdk/util-endpoints': 3.319.0
-      '@aws-sdk/util-retry': 3.310.0
-      '@aws-sdk/util-user-agent-browser': 3.310.0
-      '@aws-sdk/util-user-agent-node': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      fast-xml-parser: 4.1.2
-      tslib: 2.5.0
+  /@aws-sdk/client-sts@3.709.0:
+    resolution: {integrity: sha512-cBAvlPg6yslXNL385UUGFPw+XY+lA9BzioNdIFkMo3fEUlTShogTtiWz4LsyLHoN6LhKojssP9DSmmWKWjCZIw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@aws-crypto/sha256-browser': 5.2.0
+      '@aws-crypto/sha256-js': 5.2.0
+      '@aws-sdk/client-sso-oidc': 3.709.0(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/credential-provider-node': 3.709.0(@aws-sdk/client-sso-oidc@3.709.0)(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/middleware-host-header': 3.709.0
+      '@aws-sdk/middleware-logger': 3.709.0
+      '@aws-sdk/middleware-recursion-detection': 3.709.0
+      '@aws-sdk/middleware-user-agent': 3.709.0
+      '@aws-sdk/region-config-resolver': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@aws-sdk/util-endpoints': 3.709.0
+      '@aws-sdk/util-user-agent-browser': 3.709.0
+      '@aws-sdk/util-user-agent-node': 3.709.0
+      '@smithy/config-resolver': 3.0.13
+      '@smithy/core': 2.5.5
+      '@smithy/fetch-http-handler': 4.1.2
+      '@smithy/hash-node': 3.0.11
+      '@smithy/invalid-dependency': 3.0.11
+      '@smithy/middleware-content-length': 3.0.13
+      '@smithy/middleware-endpoint': 3.2.5
+      '@smithy/middleware-retry': 3.0.30
+      '@smithy/middleware-serde': 3.0.11
+      '@smithy/middleware-stack': 3.0.11
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/node-http-handler': 3.3.2
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/url-parser': 3.0.11
+      '@smithy/util-base64': 3.0.0
+      '@smithy/util-body-length-browser': 3.0.0
+      '@smithy/util-body-length-node': 3.0.0
+      '@smithy/util-defaults-mode-browser': 3.0.30
+      '@smithy/util-defaults-mode-node': 3.0.30
+      '@smithy/util-endpoints': 2.1.7
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-retry': 3.0.11
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
 
-  /@aws-sdk/config-resolver@3.310.0:
-    resolution: {integrity: sha512-8vsT+/50lOqfDxka9m/rRt6oxv1WuGZoP8oPMk0Dt+TxXMbAzf4+rejBgiB96wshI1k3gLokYRjSQZn+dDtT8g==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-config-provider': 3.310.0
-      '@aws-sdk/util-middleware': 3.310.0
-      tslib: 2.5.0
+  /@aws-sdk/core@3.709.0:
+    resolution: {integrity: sha512-7kuSpzdOTAE026j85wq/fN9UDZ70n0OHw81vFqMWwlEFtm5IQ/MRCLKcC4HkXxTdfy1PqFlmoXxWqeBa15tujw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@aws-sdk/types': 3.709.0
+      '@smithy/core': 2.5.5
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/property-provider': 3.1.11
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/signature-v4': 4.2.4
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/util-middleware': 3.0.11
+      fast-xml-parser: 4.4.1
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/credential-provider-env@3.310.0:
-    resolution: {integrity: sha512-vvIPQpI16fj95xwS7M3D48F7QhZJBnnCgB5lR+b7So+vsG9ibm1mZRVGzVpdxCvgyOhHFbvrby9aalNJmmIP1A==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/credential-provider-env@3.709.0:
+    resolution: {integrity: sha512-ZMAp9LSikvHDFVa84dKpQmow6wsg956Um20cKuioPpX2GGreJFur7oduD+tRJT6FtIOHn+64YH+0MwiXLhsaIQ==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/property-provider': 3.1.11
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/credential-provider-imds@3.310.0:
-    resolution: {integrity: sha512-baxK7Zp6dai5AGW01FIW27xS2KAaPUmKLIXv5SvFYsUgXXvNW55im4uG3b+2gA0F7V+hXvVBH08OEqmwW6we5w==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/credential-provider-http@3.709.0:
+    resolution: {integrity: sha512-lIS7XLwCOyJnLD70f+VIRr8DNV1HPQe9oN6aguYrhoczqz7vDiVZLe3lh714cJqq9rdxzFypK5DqKHmcscMEPQ==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/node-config-provider': 3.310.0
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/url-parser': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/fetch-http-handler': 4.1.2
+      '@smithy/node-http-handler': 3.3.2
+      '@smithy/property-provider': 3.1.11
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/util-stream': 3.3.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/credential-provider-ini@3.319.0:
-    resolution: {integrity: sha512-pzx388Fw1KlSgmIMUyRY8DJVYM3aXpwzjprD4RiQVPJeAI+t7oQmEvd2FiUZEuHDjWXcuonxgU+dk7i7HUk/HQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/credential-provider-env': 3.310.0
-      '@aws-sdk/credential-provider-imds': 3.310.0
-      '@aws-sdk/credential-provider-process': 3.310.0
-      '@aws-sdk/credential-provider-sso': 3.319.0
-      '@aws-sdk/credential-provider-web-identity': 3.310.0
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/shared-ini-file-loader': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+  /@aws-sdk/credential-provider-ini@3.709.0(@aws-sdk/client-sso-oidc@3.709.0)(@aws-sdk/client-sts@3.709.0):
+    resolution: {integrity: sha512-qCF8IIGcPoUp+Ib3ANhbF5gElxFd+kIrtv2/1tKdvhudMANstQbMiWV0LTH47ZZR6c3as4iSrm09NZnpEoD/pA==}
+    engines: {node: '>=16.0.0'}
+    peerDependencies:
+      '@aws-sdk/client-sts': ^3.709.0
+    dependencies:
+      '@aws-sdk/client-sts': 3.709.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/credential-provider-env': 3.709.0
+      '@aws-sdk/credential-provider-http': 3.709.0
+      '@aws-sdk/credential-provider-process': 3.709.0
+      '@aws-sdk/credential-provider-sso': 3.709.0(@aws-sdk/client-sso-oidc@3.709.0)
+      '@aws-sdk/credential-provider-web-identity': 3.709.0(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/types': 3.709.0
+      '@smithy/credential-provider-imds': 3.2.8
+      '@smithy/property-provider': 3.1.11
+      '@smithy/shared-ini-file-loader': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     transitivePeerDependencies:
+      - '@aws-sdk/client-sso-oidc'
       - aws-crt
     dev: false
 
-  /@aws-sdk/credential-provider-node@3.319.0:
-    resolution: {integrity: sha512-DS4a0Rdd7ZtMshoeE+zuSgbC05YBcdzd0h89u/eX+1Yqx+HCjeb8WXkbXsz0Mwx8q9TE04aS8f6Bw9J4x4mO5g==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/credential-provider-env': 3.310.0
-      '@aws-sdk/credential-provider-imds': 3.310.0
-      '@aws-sdk/credential-provider-ini': 3.319.0
-      '@aws-sdk/credential-provider-process': 3.310.0
-      '@aws-sdk/credential-provider-sso': 3.319.0
-      '@aws-sdk/credential-provider-web-identity': 3.310.0
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/shared-ini-file-loader': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+  /@aws-sdk/credential-provider-node@3.709.0(@aws-sdk/client-sso-oidc@3.709.0)(@aws-sdk/client-sts@3.709.0):
+    resolution: {integrity: sha512-4HRX9KYWPSjO5O/Vg03YAsebKpvTjTvpK1n7zHYBmlLMBLxUrVsL1nNKKC5p2/7OW3RL8XR1ki3QkoV7kGRxUQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@aws-sdk/credential-provider-env': 3.709.0
+      '@aws-sdk/credential-provider-http': 3.709.0
+      '@aws-sdk/credential-provider-ini': 3.709.0(@aws-sdk/client-sso-oidc@3.709.0)(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/credential-provider-process': 3.709.0
+      '@aws-sdk/credential-provider-sso': 3.709.0(@aws-sdk/client-sso-oidc@3.709.0)
+      '@aws-sdk/credential-provider-web-identity': 3.709.0(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/types': 3.709.0
+      '@smithy/credential-provider-imds': 3.2.8
+      '@smithy/property-provider': 3.1.11
+      '@smithy/shared-ini-file-loader': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     transitivePeerDependencies:
+      - '@aws-sdk/client-sso-oidc'
+      - '@aws-sdk/client-sts'
       - aws-crt
     dev: false
 
-  /@aws-sdk/credential-provider-process@3.310.0:
-    resolution: {integrity: sha512-h73sg6GPMUWC+3zMCbA1nZ2O03nNJt7G96JdmnantiXBwHpRKWW8nBTLzx5uhXn6hTuTaoQRP/P+oxQJKYdMmA==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/credential-provider-process@3.709.0:
+    resolution: {integrity: sha512-IAC+jPlGQII6jhIylHOwh3RgSobqlgL59nw2qYTURr8hMCI0Z1p5y2ee646HTVt4WeCYyzUAXfxr6YI/Vitv+Q==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/shared-ini-file-loader': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/property-provider': 3.1.11
+      '@smithy/shared-ini-file-loader': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/credential-provider-sso@3.319.0:
-    resolution: {integrity: sha512-gAUnWH41lxkIbANXu+Rz5zS0Iavjjmpf3C56vAMT7oaYZ3Cg/Ys5l2SwAucQGOCA2DdS2hDiSI8E+Yhr4F5toA==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/credential-provider-sso@3.709.0(@aws-sdk/client-sso-oidc@3.709.0):
+    resolution: {integrity: sha512-rYdTDOxazS2GdGScelsRK5CAkktRLCCdRjlwXaxrcW57j749hEqxcF5uTv9RD6WBwInfedcSywErNZB+hylQlg==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/client-sso': 3.319.0
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/shared-ini-file-loader': 3.310.0
-      '@aws-sdk/token-providers': 3.319.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/client-sso': 3.709.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/token-providers': 3.709.0(@aws-sdk/client-sso-oidc@3.709.0)
+      '@aws-sdk/types': 3.709.0
+      '@smithy/property-provider': 3.1.11
+      '@smithy/shared-ini-file-loader': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     transitivePeerDependencies:
+      - '@aws-sdk/client-sso-oidc'
       - aws-crt
     dev: false
 
-  /@aws-sdk/credential-provider-web-identity@3.310.0:
-    resolution: {integrity: sha512-H4SzuZXILNhK6/IR1uVvsUDZvzc051hem7GLyYghBCu8mU+tq28YhKE8MfSroi6eL2e5Vujloij1OM2EQQkPkw==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/eventstream-codec@3.310.0:
-    resolution: {integrity: sha512-clIeSgWbZbxwtsxZ/yoedNM0/kJFSIjjHPikuDGhxhqc+vP6TN3oYyVMFrYwFaTFhk2+S5wZcWYMw8Op1pWo+A==}
-    dependencies:
-      '@aws-crypto/crc32': 3.0.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-hex-encoding': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/eventstream-serde-browser@3.310.0:
-    resolution: {integrity: sha512-3S6ziuQVALgEyz0TANGtYDVeG8ArK4Y05mcgrs8qUTmsvlDIXX37cR/DvmVbNB76M4IrsZeSAIajL9644CywkA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/eventstream-serde-universal': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/eventstream-serde-config-resolver@3.310.0:
-    resolution: {integrity: sha512-8s1Qdn9STj+sV75nUp9yt0W6fHS4BZ2jTm4Z/1Pcbvh2Gqs0WjH5n2StS+pDW5Y9J/HSGBl0ogmUr5lC5bXFHg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/eventstream-serde-node@3.310.0:
-    resolution: {integrity: sha512-kSnRomCgW43K9TmQYuwN9+AoYPnhyOKroanUMyZEzJk7rpCPMj4OzaUpXfDYOvznFNYn7NLaH6nHLJAr0VPlJA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/eventstream-serde-universal': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/eventstream-serde-universal@3.310.0:
-    resolution: {integrity: sha512-Qyjt5k/waV5cDukpgT824ISZAz5U0pwzLz5ztR409u85AGNkF/9n7MS+LSyBUBSb0WJ5pUeSD47WBk+nLq9Nhw==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/eventstream-codec': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/fetch-http-handler@3.310.0:
-    resolution: {integrity: sha512-Bi9vIwzdkw1zMcvi/zGzlWS9KfIEnAq4NNhsnCxbQ4OoIRU9wvU+WGZdBBhxg0ZxZmpp1j1aZhU53lLjA07MHw==}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/querystring-builder': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-base64': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/hash-blob-browser@3.310.0:
-    resolution: {integrity: sha512-OoR8p0cbypToysLT0v3o2oyjy6+DKrY7GNCAzHOHJK9xmqXCt+DsjKoPeiY7o1sWX2aN6Plmvubj/zWxMKEn/A==}
-    dependencies:
-      '@aws-sdk/chunked-blob-reader': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/hash-node@3.310.0:
-    resolution: {integrity: sha512-NvE2fhRc8GRwCXBfDehxVAWCmVwVMILliAKVPAEr4yz2CkYs0tqU51S48x23dtna07H4qHtgpeNqVTthcIQOEQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-buffer-from': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/hash-stream-node@3.310.0:
-    resolution: {integrity: sha512-ZoXdybNgvMz1Hl6k/e32xVL3jmG5p2IEk5mTtLfFEuskTJ74Z+VMYKkkF1whyy7KQfH83H+TQGnsGtlRCchQKw==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/invalid-dependency@3.310.0:
-    resolution: {integrity: sha512-1s5RG5rSPXoa/aZ/Kqr5U/7lqpx+Ry81GprQ2bxWqJvWQIJ0IRUwo5pk8XFxbKVr/2a+4lZT/c3OGoBOM1yRRA==}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/is-array-buffer@3.310.0:
-    resolution: {integrity: sha512-urnbcCR+h9NWUnmOtet/s4ghvzsidFmspfhYaHAmSRdy9yDjdjBJMFjjsn85A1ODUktztm+cVncXjQ38WCMjMQ==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/credential-provider-web-identity@3.709.0(@aws-sdk/client-sts@3.709.0):
+    resolution: {integrity: sha512-2lbDfE0IQ6gma/7BB2JpkjW5G0wGe4AS0x80oybYAYYviJmUtIR3Cn2pXun6bnAWElt4wYKl4su7oC36rs5rNA==}
+    engines: {node: '>=16.0.0'}
+    peerDependencies:
+      '@aws-sdk/client-sts': ^3.709.0
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/client-sts': 3.709.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/property-provider': 3.1.11
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/lib-storage@3.319.0(@aws-sdk/abort-controller@3.374.0)(@aws-sdk/client-s3@3.319.0):
-    resolution: {integrity: sha512-/iWG61UTaUJO3Lfb/jhVk8BMVaFjiUplIqrDQTid2rcBEGJsepbuIL/+mas7redbN+4aOMQTioBZcTCapdef6Q==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/lib-storage@3.709.0(@aws-sdk/client-s3@3.709.0):
+    resolution: {integrity: sha512-TnP+QSsWdiaQYS5HuB3n9H947z49m6qSEv5fth4L9xinBldLepLyyF+cua3/GlagkWqpxcATISgR9pE1PB0mhQ==}
+    engines: {node: '>=16.0.0'}
     peerDependencies:
-      '@aws-sdk/abort-controller': ^3.0.0
-      '@aws-sdk/client-s3': ^3.0.0
+      '@aws-sdk/client-s3': ^3.709.0
     dependencies:
-      '@aws-sdk/abort-controller': 3.374.0
-      '@aws-sdk/client-s3': 3.319.0
-      '@aws-sdk/middleware-endpoint': 3.310.0
-      '@aws-sdk/smithy-client': 3.316.0
+      '@aws-sdk/client-s3': 3.709.0
+      '@smithy/abort-controller': 3.1.9
+      '@smithy/middleware-endpoint': 3.2.5
+      '@smithy/smithy-client': 3.5.0
       buffer: 5.6.0
       events: 3.3.0
       stream-browserify: 3.0.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/md5-js@3.310.0:
-    resolution: {integrity: sha512-x5sRBUrEfLWAS1EhwbbDQ7cXq6uvBxh3qR2XAsnGvFFceTeAadk7cVogWxlk3PC+OCeeym7c3/6Bv2HQ2f1YyQ==}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-bucket-endpoint@3.310.0:
-    resolution: {integrity: sha512-uJJfHI7v4AgbJZRLtyI8ap2QRWkBokGc3iyUoQ+dVNT3/CE2ZCu694A6W+H0dRqg79dIE+f9CRNdtLGa/Ehhvg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-arn-parser': 3.310.0
-      '@aws-sdk/util-config-provider': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-content-length@3.310.0:
-    resolution: {integrity: sha512-P8tQZxgDt6CAh1wd/W6WPzjc+uWPJwQkm+F7rAwRlM+k9q17HrhnksGDKcpuuLyIhPQYdmOMIkpKVgXGa4avhQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-endpoint@3.310.0:
-    resolution: {integrity: sha512-Z+N2vOL8K354/lstkClxLLsr6hCpVRh+0tCMXrVj66/NtKysCEZ/0b9LmqOwD9pWHNiI2mJqXwY0gxNlKAroUg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/middleware-serde': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/url-parser': 3.310.0
-      '@aws-sdk/util-middleware': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-expect-continue@3.310.0:
-    resolution: {integrity: sha512-l3d1z2gt+gINJDnPSyu84IxfzjzPfCQrqC1sunw2cZGo/sXtEiq698Q3SiTcO2PGP4LBQAy2RHb5wVBJP708CQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-flexible-checksums@3.310.0:
-    resolution: {integrity: sha512-5ndnLgzgGVpWkmHBAiYkagHqiSuow8q62J4J6E2PzaQ77+fm8W3nfdy7hK5trHokEyouCZdxT/XK/IRhgj/4PA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-crypto/crc32': 3.0.0
-      '@aws-crypto/crc32c': 3.0.0
-      '@aws-sdk/is-array-buffer': 3.310.0
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-host-header@3.310.0:
-    resolution: {integrity: sha512-QWSA+46/hXorXyWa61ic2K7qZzwHTiwfk2e9mRRjeIRepUgI3qxFjsYqrWtrOGBjmFmq0pYIY8Bb/DCJuQqcoA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-location-constraint@3.310.0:
-    resolution: {integrity: sha512-LFm0JTQWwTPWL/tZU2wsQTl8J5PpDEkXjEhaXVKamtyH0xhysRqd+0n92n65dc8oztAuQkb9xUbErGn5b6gsew==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-logger@3.310.0:
-    resolution: {integrity: sha512-Lurm8XofrASBRnAVtiSNuDSRsRqPNg27RIFLLsLp/pqog9nFJ0vz0kgdb9S5Z+zw83Mm+UlqOe6D8NTUNp4fVg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-recursion-detection@3.310.0:
-    resolution: {integrity: sha512-SuB75/xk/gyue24gkriTwO2jFd7YcUGZDClQYuRejgbXSa3CO0lWyawQtfLcSSEBp9izrEVXuFH24K1eAft5nQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-retry@3.310.0:
-    resolution: {integrity: sha512-oTPsRy2W4s+dfxbJPW7Km+hHtv/OMsNsVfThAq8DDYKC13qlr1aAyOqGLD+dpBy2aKe7ss517Sy2HcHtHqm7/g==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/service-error-classification': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-middleware': 3.310.0
-      '@aws-sdk/util-retry': 3.310.0
-      tslib: 2.5.0
-      uuid: 8.3.2
-    dev: false
-
-  /@aws-sdk/middleware-sdk-s3@3.310.0:
-    resolution: {integrity: sha512-QK9x9g2ksg0hOjjYgqddeFcn5ctUEGdxJVu4OumPXceulefMcSO2jyH2qTybYSA93nqNQFdFmg5wQfvIRUWFCQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-arn-parser': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-sdk-sts@3.310.0:
-    resolution: {integrity: sha512-+5PFwlYNLvLLIfw0ASAoWV/iIF8Zv6R6QGtyP0CclhRSvNjgbQDVnV0g95MC5qvh+GB/Yjlkt8qAjLSPjHfsrQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/middleware-signing': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-serde@3.310.0:
-    resolution: {integrity: sha512-RNeeTVWSLTaentUeCgQKZhAl+C6hxtwD78cQWS10UymWpQFwbaxztzKUu4UQS5xA2j6PxwPRRUjqa4jcFjfLsg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-signing@3.310.0:
-    resolution: {integrity: sha512-f9mKq+XMdW207Af3hKjdTnpNhdtwqWuvFs/ZyXoOkp/g1MY1O6L23Jy6i52m29LxbT4AuNRG1oKODfXM0vYVjQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/signature-v4': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-middleware': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-ssec@3.310.0:
-    resolution: {integrity: sha512-CnEwNKVpd5bXnrCKPaePF8mWTA9ET21OMBb54y9b0fd8K02zoOcdBz4DWfh1SjFD4HkgCdja4egd8l2ivyvqmw==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-stack@3.310.0:
-    resolution: {integrity: sha512-010O1PD+UAcZVKRvqEusE1KJqN96wwrf6QsqbRM0ywsKQ21NDweaHvEDlds2VHpgmofxkRLRu/IDrlPkKRQrRg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/middleware-user-agent@3.319.0:
-    resolution: {integrity: sha512-ytaLx2dlR5AdMSne6FuDCISVg8hjyKj+cHU20b2CRA/E/z+XXrLrssp4JrCgizRKPPUep0psMIa22Zd6osTT5Q==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-endpoints': 3.319.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/node-config-provider@3.310.0:
-    resolution: {integrity: sha512-T/Pp6htc6hq/Cq+MLNDSyiwWCMVF6GqbBbXKVlO5L8rdHx4sq9xPdoPveZhGWrxvkanjA6eCwUp6E0riBOSVng==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/shared-ini-file-loader': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/node-http-handler@3.310.0:
-    resolution: {integrity: sha512-irv9mbcM9xC2xYjArQF5SYmHBMu4ciMWtGsoHII1nRuFOl9FoT4ffTvEPuLlfC6pznzvKt9zvnm6xXj7gDChKg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/abort-controller': 3.310.0
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/querystring-builder': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/property-provider@3.310.0:
-    resolution: {integrity: sha512-3lxDb0akV6BBzmFe4nLPaoliQbAifyWJhuvuDOu7e8NzouvpQXs0275w9LePhhcgjKAEVXUIse05ZW2DLbxo/g==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/protocol-http@3.310.0:
-    resolution: {integrity: sha512-fgZ1aw/irQtnrsR58pS8ThKOWo57Py3xX6giRvwSgZDEcxHfVzuQjy9yPuV++v04fdmdtgpbGf8WfvAAJ11yXQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/querystring-builder@3.310.0:
-    resolution: {integrity: sha512-ZHH8GV/80+pWGo7DzsvwvXR5xVxUHXUvPJPFAkhr6nCf78igdoF8gR10ScFoEKbtEapoNTaZlKHPXxpD8aPG7A==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-uri-escape': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/querystring-parser@3.310.0:
-    resolution: {integrity: sha512-YkIznoP6lsiIUHinx++/lbb3tlMURGGqMpo0Pnn32zYzGrJXA6eC3D0as2EcMjo55onTfuLcIiX4qzXes2MYOA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/service-error-classification@3.310.0:
-    resolution: {integrity: sha512-PuyC7k3qfIKeH2LCnDwbttMOKq3qAx4buvg0yfnJtQOz6t1AR8gsnAq0CjKXXyfkXwNKWTqCpE6lVNUIkXgsMw==}
-    engines: {node: '>=14.0.0'}
-    dev: false
-
-  /@aws-sdk/shared-ini-file-loader@3.310.0:
-    resolution: {integrity: sha512-N0q9pG0xSjQwc690YQND5bofm+4nfUviQ/Ppgan2kU6aU0WUq8KwgHJBto/YEEI+VlrME30jZJnxtOvcZJc2XA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/signature-v4-multi-region@3.310.0:
-    resolution: {integrity: sha512-q8W+RIomTS/q85Ntgks/CoDElwqkC9+4OCicee5YznNHjQ4gtNWhUkYIyIRWRmXa/qx/AUreW9DM8FAecCOdng==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      '@aws-sdk/signature-v4-crt': ^3.118.0
-    peerDependenciesMeta:
-      '@aws-sdk/signature-v4-crt':
-        optional: true
-    dependencies:
-      '@aws-sdk/protocol-http': 3.310.0
-      '@aws-sdk/signature-v4': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/signature-v4@3.310.0:
-    resolution: {integrity: sha512-1M60P1ZBNAjCFv9sYW29OF6okktaeibWyW3lMXqzoHF70lHBZh+838iUchznXUA5FLabfn4jBFWMRxlAXJUY2Q==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/is-array-buffer': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-hex-encoding': 3.310.0
-      '@aws-sdk/util-middleware': 3.310.0
-      '@aws-sdk/util-uri-escape': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/smithy-client@3.316.0:
-    resolution: {integrity: sha512-6YXOKbRnXeS8r8RWzuL6JMBolDYM5Wa4fD/VY6x/wK78i2xErHOvqzHgyyeLI1MMw4uqyd4wRNJNWC9TMPduXw==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/middleware-stack': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/token-providers@3.319.0:
-    resolution: {integrity: sha512-5utg6VL6Pl0uiLUn8ZJPYYxzCb9VRPsgJmGXktRUwq0YlTJ6ABcaxTXwZcC++sjh/qyCQDK5PPLNU5kIBttHMQ==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/client-sso-oidc': 3.319.0
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/shared-ini-file-loader': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    transitivePeerDependencies:
-      - aws-crt
-    dev: false
-
-  /@aws-sdk/types@3.310.0:
-    resolution: {integrity: sha512-j8eamQJ7YcIhw7fneUfs8LYl3t01k4uHi4ZDmNRgtbmbmTTG3FZc2MotStZnp3nZB6vLiPF1o5aoJxWVvkzS6A==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      tslib: 2.5.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/url-parser@3.310.0:
-    resolution: {integrity: sha512-mCLnCaSB9rQvAgx33u0DujLvr4d5yEm/W5r789GblwwQnlNXedVu50QRizMLTpltYWyAUoXjJgQnJHmJMaKXhw==}
+  /@aws-sdk/middleware-bucket-endpoint@3.709.0:
+    resolution: {integrity: sha512-03+tJOd7KIZOiqWH7Z8BOfQIWkKJgjcpKOJKZ6FR2KjWGUOE1G+bo11wF4UuHQ0RmpKnApt+pQghZmSnE7WEeg==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/querystring-parser': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@aws-sdk/util-arn-parser': 3.693.0
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      '@smithy/util-config-provider': 3.0.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-arn-parser@3.310.0:
-    resolution: {integrity: sha512-jL8509owp/xB9+Or0pvn3Fe+b94qfklc2yPowZZIFAkFcCSIdkIglz18cPDWnYAcy9JGewpMS1COXKIUhZkJsA==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/middleware-expect-continue@3.709.0:
+    resolution: {integrity: sha512-Tbl/DFvE4rHl8lMb9IzetwK4tf5R3VeHZkvEXQalsWoK0tbEQ8kXWi7wAYO4qbE7bFVvaxKX+irjJjTxf3BrCQ==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-base64@3.310.0:
-    resolution: {integrity: sha512-v3+HBKQvqgdzcbL+pFswlx5HQsd9L6ZTlyPVL2LS9nNXnCcR3XgGz9jRskikRUuUvUXtkSG1J88GAOnJ/apTPg==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/util-buffer-from': 3.310.0
-      tslib: 2.5.0
+  /@aws-sdk/middleware-flexible-checksums@3.709.0:
+    resolution: {integrity: sha512-wbYm9tkyCaqMeU82yjaXw7V5BxCSlSLNupENW63LC7Fvyo/aQzj6LjSMHcBpR2QwjBEhXCtF47L7aQ8SPTNhdw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@aws-crypto/crc32': 5.2.0
+      '@aws-crypto/crc32c': 5.2.0
+      '@aws-crypto/util': 5.2.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/is-array-buffer': 3.0.0
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-stream': 3.3.2
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-body-length-browser@3.310.0:
-    resolution: {integrity: sha512-sxsC3lPBGfpHtNTUoGXMQXLwjmR0zVpx0rSvzTPAuoVILVsp5AU/w5FphNPxD5OVIjNbZv9KsKTuvNTiZjDp9g==}
+  /@aws-sdk/middleware-host-header@3.709.0:
+    resolution: {integrity: sha512-8gQYCYAaIw4lOCd5WYdf15Y/61MgRsAnrb2eiTl+icMlUOOzl8aOl5iDwm/Idp0oHZTflwxM4XSvGXO83PRWcw==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-body-length-node@3.310.0:
-    resolution: {integrity: sha512-2tqGXdyKhyA6w4zz7UPoS8Ip+7sayOg9BwHNidiGm2ikbDxm1YrCfYXvCBdwaJxa4hJfRVz+aL9e+d3GqPI9pQ==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/middleware-location-constraint@3.709.0:
+    resolution: {integrity: sha512-5YQWPXfZq7OE0jB2G0PP8K10GBod/YPJXb+1CfJS6FbQaglRoIm8KZmVEvJNnptSKyGtE62veeCcCQcfAUfFig==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-buffer-from@3.310.0:
-    resolution: {integrity: sha512-i6LVeXFtGih5Zs8enLrt+ExXY92QV25jtEnTKHsmlFqFAuL3VBeod6boeMXkN2p9lbSVVQ1sAOOYZOHYbYkntw==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/middleware-logger@3.709.0:
+    resolution: {integrity: sha512-jDoGSccXv9zebnpUoisjWd5u5ZPIalrmm6TjvPzZ8UqzQt3Beiz0tnQwmxQD6KRc7ADweWP5Ntiqzbw9xpVajg==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/is-array-buffer': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-config-provider@3.310.0:
-    resolution: {integrity: sha512-xIBaYo8dwiojCw8vnUcIL4Z5tyfb1v3yjqyJKJWV/dqKUFOOS0U591plmXbM+M/QkXyML3ypon1f8+BoaDExrg==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/middleware-recursion-detection@3.709.0:
+    resolution: {integrity: sha512-PObL/wLr4lkfbQ0yXUWaoCWu/jcwfwZzCjsUiXW/H6hW9b/00enZxmx7OhtJYaR6xmh/Lcx5wbhIoDCbzdv0tw==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-defaults-mode-browser@3.316.0:
-    resolution: {integrity: sha512-6FSqLhYmaihtH2n1s4b2rlLW0ABU8N6VZIfzLfe2ING4PF0MzfaMMhnTFUHVXfKCVGoR8yP6iyFTRCyHGVEL1w==}
-    engines: {node: '>= 10.0.0'}
-    dependencies:
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      bowser: 2.11.0
-      tslib: 2.5.0
+  /@aws-sdk/middleware-sdk-s3@3.709.0:
+    resolution: {integrity: sha512-FwtOG9t9xsLoLOQZ6qAdsWOjx9dsO6t28IjIDV1l6Ixiu2oC0Yks7goONjJUH0IDE4pDDDGzmuq0sn1XtHhheA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@aws-sdk/util-arn-parser': 3.693.0
+      '@smithy/core': 2.5.5
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/signature-v4': 4.2.4
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/util-config-provider': 3.0.0
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-stream': 3.3.2
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-defaults-mode-node@3.316.0:
-    resolution: {integrity: sha512-dkYy10hdjPSScXXvnjGpZpnJxllkb6ICHgLMwZ4JczLHhPM12T/4PQ758YN8HS+muiYDGX1Bl2z1jd/bMcewBQ==}
-    engines: {node: '>= 10.0.0'}
+  /@aws-sdk/middleware-ssec@3.709.0:
+    resolution: {integrity: sha512-2muiLe7YkmlwZp2SKz+goZrDThGfRq3o0FcJF3Puc0XGmcEPEDjih537mCoTrGgcXNFlBc7YChd84r3t72ySaQ==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/config-resolver': 3.310.0
-      '@aws-sdk/credential-provider-imds': 3.310.0
-      '@aws-sdk/node-config-provider': 3.310.0
-      '@aws-sdk/property-provider': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-endpoints@3.319.0:
-    resolution: {integrity: sha512-3I64UMoYA2e2++oOUJXRcFtYLpLylnZFRltWfPo1B3dLlf+MIWat9djT+mMus+hW1ntLsvAIVu1hLVePJC0gvw==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/middleware-user-agent@3.709.0:
+    resolution: {integrity: sha512-ooc9ZJvgkjPhi9q05XwSfNTXkEBEIfL4hleo5rQBKwHG3aTHvwOM7LLzhdX56QZVa6sorPBp6fwULuRDSqiQHw==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/core': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@aws-sdk/util-endpoints': 3.709.0
+      '@smithy/core': 2.5.5
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-hex-encoding@3.310.0:
-    resolution: {integrity: sha512-sVN7mcCCDSJ67pI1ZMtk84SKGqyix6/0A1Ab163YKn+lFBQRMKexleZzpYzNGxYzmQS6VanP/cfU7NiLQOaSfA==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/region-config-resolver@3.709.0:
+    resolution: {integrity: sha512-/NoCAMEVKAg3kBKOrNtgOfL+ECt6nrl+L7q2SyYmrcY4tVCmwuECVqewQaHc03fTnJijfKLccw0Fj+6wOCnB6w==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/types': 3.7.2
+      '@smithy/util-config-provider': 3.0.0
+      '@smithy/util-middleware': 3.0.11
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-locate-window@3.310.0:
-    resolution: {integrity: sha512-qo2t/vBTnoXpjKxlsC2e1gBrRm80M3bId27r0BRB2VniSSe7bL1mmzM+/HFtujm0iAxtPM+aLEflLJlJeDPg0w==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/signature-v4-multi-region@3.709.0:
+    resolution: {integrity: sha512-m0vhJEy6SLbjL11K9cHzX/ZhCIj//1GkTbYk2d4tTQFSuPyJEkjmoeHk9dYm2mJy0wH48j29OJadI1JUsR5bOw==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/middleware-sdk-s3': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/signature-v4': 4.2.4
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-middleware@3.310.0:
-    resolution: {integrity: sha512-FTSUKL/eRb9X6uEZClrTe27QFXUNNp7fxYrPndZwk1hlaOP5ix+MIHBcI7pIiiY/JPfOUmPyZOu+HetlFXjWog==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/token-providers@3.709.0(@aws-sdk/client-sso-oidc@3.709.0):
+    resolution: {integrity: sha512-q5Ar6k71nci43IbULFgC8a89d/3EHpmd7HvBzqVGRcHnoPwh8eZDBfbBXKH83NGwcS1qPSRYiDbVfeWPm4/1jA==}
+    engines: {node: '>=16.0.0'}
+    peerDependencies:
+      '@aws-sdk/client-sso-oidc': ^3.709.0
     dependencies:
-      tslib: 2.5.0
+      '@aws-sdk/client-sso-oidc': 3.709.0(@aws-sdk/client-sts@3.709.0)
+      '@aws-sdk/types': 3.709.0
+      '@smithy/property-provider': 3.1.11
+      '@smithy/shared-ini-file-loader': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-retry@3.310.0:
-    resolution: {integrity: sha512-FwWGhCBLfoivTMUHu1LIn4NjrN9JLJ/aX5aZmbcPIOhZVFJj638j0qDgZXyfvVqBuBZh7M8kGq0Oahy3dp69OA==}
-    engines: {node: '>= 14.0.0'}
+  /@aws-sdk/types@3.709.0:
+    resolution: {integrity: sha512-ArtLTMxgjf13Kfu3gWH3Ez9Q5TkDdcRZUofpKH3pMGB/C6KAbeSCtIIDKfoRTUABzyGlPyCrZdnFjKyH+ypIpg==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/service-error-classification': 3.310.0
-      tslib: 2.5.0
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-stream-browser@3.310.0:
-    resolution: {integrity: sha512-bysXZHwFwvbqOTCScCdCnoLk1K3GCo0HRIYEZuL7O7MHrQmfaYRXcaft/p22+GUv9VeFXS/eJJZ5r4u32az94w==}
+  /@aws-sdk/util-arn-parser@3.693.0:
+    resolution: {integrity: sha512-WC8x6ca+NRrtpAH64rWu+ryDZI3HuLwlEr8EU6/dbC/pt+r/zC0PBoC15VEygUaBA+isppCikQpGyEDu0Yj7gQ==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/fetch-http-handler': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-base64': 3.310.0
-      '@aws-sdk/util-hex-encoding': 3.310.0
-      '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-stream-node@3.310.0:
-    resolution: {integrity: sha512-hueAXFK0GVvnfYFgqbF7587xZfMZff5jlIFZOHqx7XVU7bl7qrRUCnphHk8H6yZ7RoQbDPcfmHJgtEoAJg1T1Q==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/util-endpoints@3.709.0:
+    resolution: {integrity: sha512-Mbc7AtL5WGCTKC16IGeUTz+sjpC3ptBda2t0CcK0kMVw3THDdcSq6ZlNKO747cNqdbwUvW34oHteUiHv4/z88Q==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      '@aws-sdk/node-http-handler': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      '@aws-sdk/util-buffer-from': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/types': 3.7.2
+      '@smithy/util-endpoints': 2.1.7
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-uri-escape@3.310.0:
-    resolution: {integrity: sha512-drzt+aB2qo2LgtDoiy/3sVG8w63cgLkqFIa2NFlGpUgHFWTXkqtbgf4L5QdjRGKWhmZsnqkbtL7vkSWEcYDJ4Q==}
+  /@aws-sdk/util-locate-window@3.310.0:
+    resolution: {integrity: sha512-qo2t/vBTnoXpjKxlsC2e1gBrRm80M3bId27r0BRB2VniSSe7bL1mmzM+/HFtujm0iAxtPM+aLEflLJlJeDPg0w==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      tslib: 2.5.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-user-agent-browser@3.310.0:
-    resolution: {integrity: sha512-yU/4QnHHuQ5z3vsUqMQVfYLbZGYwpYblPiuZx4Zo9+x0PBkNjYMqctdDcrpoH9Z2xZiDN16AmQGK1tix117ZKw==}
+  /@aws-sdk/util-user-agent-browser@3.709.0:
+    resolution: {integrity: sha512-/rL2GasJzdTWUURCQKFldw2wqBtY4k4kCiA2tVZSKg3y4Ey7zO34SW8ebaeCE2/xoWOyLR2/etdKyphoo4Zrtg==}
     dependencies:
-      '@aws-sdk/types': 3.310.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/types': 3.7.2
       bowser: 2.11.0
-      tslib: 2.5.0
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/util-user-agent-node@3.310.0:
-    resolution: {integrity: sha512-Ra3pEl+Gn2BpeE7KiDGpi4zj7WJXZA5GXnGo3mjbi9+Y3zrbuhJAbdZO3mO/o7xDgMC6ph4xCTbaSGzU6b6EDg==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/util-user-agent-node@3.709.0:
+    resolution: {integrity: sha512-trBfzSCVWy7ILgqhEXgiuM7hfRCw4F4a8IK90tjk9YL0jgoJ6eJuOp7+DfCtHJaygoBxD3cdMFkOu+lluFmGBA==}
+    engines: {node: '>=16.0.0'}
     peerDependencies:
       aws-crt: '>=1.0.0'
     peerDependenciesMeta:
       aws-crt:
         optional: true
     dependencies:
-      '@aws-sdk/node-config-provider': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/util-utf8-browser@3.259.0:
-    resolution: {integrity: sha512-UvFa/vR+e19XookZF8RzFZBrw2EUkQWxiBW0yYQAhvk3C+QVGl0H3ouca8LDBlBfQKXwmW3huo/59H8rwb1wJw==}
-    dependencies:
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/util-utf8@3.310.0:
-    resolution: {integrity: sha512-DnLfFT8uCO22uOJc0pt0DsSNau1GTisngBCDw8jQuWT5CqogMJu4b/uXmwEqfj8B3GX6Xsz8zOd6JpRlPftQoA==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/util-buffer-from': 3.310.0
-      tslib: 2.5.0
-    dev: false
-
-  /@aws-sdk/util-waiter@3.310.0:
-    resolution: {integrity: sha512-AV5j3guH/Y4REu+Qh3eXQU9igljHuU4XjX2sADAgf54C0kkhcCCkkiuzk3IsX089nyJCqIcj5idbjdvpnH88Vw==}
-    engines: {node: '>=14.0.0'}
-    dependencies:
-      '@aws-sdk/abort-controller': 3.310.0
-      '@aws-sdk/types': 3.310.0
-      tslib: 2.5.0
+      '@aws-sdk/middleware-user-agent': 3.709.0
+      '@aws-sdk/types': 3.709.0
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
-  /@aws-sdk/xml-builder@3.310.0:
-    resolution: {integrity: sha512-TqELu4mOuSIKQCqj63fGVs86Yh+vBx5nHRpWKNUNhB2nPTpfbziTs5c1X358be3peVWA4wPxW7Nt53KIg1tnNw==}
-    engines: {node: '>=14.0.0'}
+  /@aws-sdk/xml-builder@3.709.0:
+    resolution: {integrity: sha512-2GPCwlNxeHspoK/Mc8nbk9cBOkSpp3j2SJUQmFnyQK6V/pR6II2oPRyZkMomug1Rc10hqlBHByMecq4zhV2uUw==}
+    engines: {node: '>=16.0.0'}
     dependencies:
-      tslib: 2.5.0
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
     dev: false
 
   /@babel/cli@7.21.0(@babel/core@7.21.4):
@@ -3122,8 +2794,8 @@ packages:
     engines: {node: '>=12'}
     dev: false
 
-  /@posthog/hogvm@1.0.61(luxon@3.4.4):
-    resolution: {integrity: sha512-zCwQp6Zn2F2/QNhd1/0IwpndhElVZ2pzsoh2IOZWapZ+jNo6y/taL3128Uwoiec01IYiPXF8EVYOJP7X4Woj+A==}
+  /@posthog/hogvm@1.0.64(luxon@3.4.4):
+    resolution: {integrity: sha512-s6l5IhrtfLWXapW7Bl/YDvwX7hng9ypmhGul6Tljxu4ea5TBgexowf9+BhIGKo2JIUzyaZbLvDwQpTQopR1qvA==}
     peerDependencies:
       luxon: ^3.4.4
     dependencies:
@@ -3300,18 +2972,484 @@ packages:
       '@sinonjs/commons': 1.8.6
     dev: true
 
-  /@smithy/abort-controller@1.1.0:
-    resolution: {integrity: sha512-5imgGUlZL4dW4YWdMYAKLmal9ny/tlenM81QZY7xYyb76z9Z/QOg7oM5Ak9HQl8QfFTlGVWwcMXl+54jroRgEQ==}
+  /@smithy/abort-controller@3.1.9:
+    resolution: {integrity: sha512-yiW0WI30zj8ZKoSYNx90no7ugVn3khlyH/z5W8qtKBtVE6awRALbhSG+2SAHA1r6bO/6M9utxYKVZ3PCJ1rWxw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/chunked-blob-reader-native@3.0.1:
+    resolution: {integrity: sha512-VEYtPvh5rs/xlyqpm5NRnfYLZn+q0SRPELbvBV+C/G7IQ+ouTuo+NKKa3ShG5OaFR8NYVMXls9hPYLTvIKKDrQ==}
+    dependencies:
+      '@smithy/util-base64': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/chunked-blob-reader@4.0.0:
+    resolution: {integrity: sha512-jSqRnZvkT4egkq/7b6/QRCNXmmYVcHwnJldqJ3IhVpQE2atObVJ137xmGeuGFhjFUr8gCEVAOKwSY79OvpbDaQ==}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/config-resolver@3.0.13:
+    resolution: {integrity: sha512-Gr/qwzyPaTL1tZcq8WQyHhTZREER5R1Wytmz4WnVGL4onA3dNk6Btll55c8Vr58pLdvWZmtG8oZxJTw3t3q7Jg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/types': 3.7.2
+      '@smithy/util-config-provider': 3.0.0
+      '@smithy/util-middleware': 3.0.11
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/core@2.5.5:
+    resolution: {integrity: sha512-G8G/sDDhXA7o0bOvkc7bgai6POuSld/+XhNnWAbpQTpLv2OZPvyqQ58tLPPlz0bSNsXktldDDREIv1LczFeNEw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/middleware-serde': 3.0.11
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      '@smithy/util-body-length-browser': 3.0.0
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-stream': 3.3.2
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/credential-provider-imds@3.2.8:
+    resolution: {integrity: sha512-ZCY2yD0BY+K9iMXkkbnjo+08T2h8/34oHd0Jmh6BZUSZwaaGlGCyBT/3wnS7u7Xl33/EEfN4B6nQr3Gx5bYxgw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/property-provider': 3.1.11
+      '@smithy/types': 3.7.2
+      '@smithy/url-parser': 3.0.11
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/eventstream-codec@3.1.10:
+    resolution: {integrity: sha512-323B8YckSbUH0nMIpXn7HZsAVKHYHFUODa8gG9cHo0ySvA1fr5iWaNT+iIL0UCqUzG6QPHA3BSsBtRQou4mMqQ==}
+    dependencies:
+      '@aws-crypto/crc32': 5.2.0
+      '@smithy/types': 3.7.2
+      '@smithy/util-hex-encoding': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/eventstream-serde-browser@3.0.14:
+    resolution: {integrity: sha512-kbrt0vjOIihW3V7Cqj1SXQvAI5BR8SnyQYsandva0AOR307cXAc+IhPngxIPslxTLfxwDpNu0HzCAq6g42kCPg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/eventstream-serde-universal': 3.0.13
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/eventstream-serde-config-resolver@3.0.11:
+    resolution: {integrity: sha512-P2pnEp4n75O+QHjyO7cbw/vsw5l93K/8EWyjNCAAybYwUmj3M+hjSQZ9P5TVdUgEG08ueMAP5R4FkuSkElZ5tQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/eventstream-serde-node@3.0.13:
+    resolution: {integrity: sha512-zqy/9iwbj8Wysmvi7Lq7XFLeDgjRpTbCfwBhJa8WbrylTAHiAu6oQTwdY7iu2lxigbc9YYr9vPv5SzYny5tCXQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/eventstream-serde-universal': 3.0.13
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/eventstream-serde-universal@3.0.13:
+    resolution: {integrity: sha512-L1Ib66+gg9uTnqp/18Gz4MDpJPKRE44geOjOQ2SVc0eiaO5l255ADziATZgjQjqumC7yPtp1XnjHlF1srcwjKw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/eventstream-codec': 3.1.10
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/fetch-http-handler@4.1.2:
+    resolution: {integrity: sha512-R7rU7Ae3ItU4rC0c5mB2sP5mJNbCfoDc8I5XlYjIZnquyUwec7fEo78F6DA3SmgJgkU1qTMcZJuGblxZsl10ZA==}
+    dependencies:
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/querystring-builder': 3.0.11
+      '@smithy/types': 3.7.2
+      '@smithy/util-base64': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/hash-blob-browser@3.1.10:
+    resolution: {integrity: sha512-elwslXOoNunmfS0fh55jHggyhccobFkexLYC1ZeZ1xP2BTSrcIBaHV2b4xUQOdctrSNOpMqOZH1r2XzWTEhyfA==}
+    dependencies:
+      '@smithy/chunked-blob-reader': 4.0.0
+      '@smithy/chunked-blob-reader-native': 3.0.1
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/hash-node@3.0.11:
+    resolution: {integrity: sha512-emP23rwYyZhQBvklqTtwetkQlqbNYirDiEEwXl2v0GYWMnCzxst7ZaRAnWuy28njp5kAH54lvkdG37MblZzaHA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      '@smithy/util-buffer-from': 3.0.0
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/hash-stream-node@3.1.10:
+    resolution: {integrity: sha512-olomK/jZQ93OMayW1zfTHwcbwBdhcZOHsyWyiZ9h9IXvc1mCD/VuvzbLb3Gy/qNJwI4MANPLctTp2BucV2oU/Q==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/invalid-dependency@3.0.11:
+    resolution: {integrity: sha512-NuQmVPEJjUX6c+UELyVz8kUx8Q539EDeNwbRyu4IIF8MeV7hUtq1FB3SHVyki2u++5XLMFqngeMKk7ccspnNyQ==}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/is-array-buffer@2.2.0:
+    resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==}
+    engines: {node: '>=14.0.0'}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/is-array-buffer@3.0.0:
+    resolution: {integrity: sha512-+Fsu6Q6C4RSJiy81Y8eApjEB5gVtM+oFKTffg+jSuwtvomJJrhUJBu2zS8wjXSgH/g1MKEWrzyChTBe6clb5FQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/md5-js@3.0.11:
+    resolution: {integrity: sha512-3NM0L3i2Zm4bbgG6Ymi9NBcxXhryi3uE8fIfHJZIOfZVxOkGdjdgjR9A06SFIZCfnEIWKXZdm6Yq5/aPXFFhsQ==}
+    dependencies:
+      '@smithy/types': 3.7.2
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/middleware-content-length@3.0.13:
+    resolution: {integrity: sha512-zfMhzojhFpIX3P5ug7jxTjfUcIPcGjcQYzB9t+rv0g1TX7B0QdwONW+ATouaLoD7h7LOw/ZlXfkq4xJ/g2TrIw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/middleware-endpoint@3.2.5:
+    resolution: {integrity: sha512-VhJNs/s/lyx4weiZdXSloBgoLoS8osV0dKIain8nGmx7of3QFKu5BSdEuk1z/U8x9iwes1i+XCiNusEvuK1ijg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/core': 2.5.5
+      '@smithy/middleware-serde': 3.0.11
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/shared-ini-file-loader': 3.1.12
+      '@smithy/types': 3.7.2
+      '@smithy/url-parser': 3.0.11
+      '@smithy/util-middleware': 3.0.11
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/middleware-retry@3.0.30:
+    resolution: {integrity: sha512-6323RL2BvAR3VQpTjHpa52kH/iSHyxd/G9ohb2MkBk2Ucu+oMtRXT8yi7KTSIS9nb58aupG6nO0OlXnQOAcvmQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/service-error-classification': 3.0.11
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-retry': 3.0.11
+      tslib: 2.6.2
+      uuid: 9.0.1
+    dev: false
+
+  /@smithy/middleware-serde@3.0.11:
+    resolution: {integrity: sha512-KzPAeySp/fOoQA82TpnwItvX8BBURecpx6ZMu75EZDkAcnPtO6vf7q4aH5QHs/F1s3/snQaSFbbUMcFFZ086Mw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/middleware-stack@3.0.11:
+    resolution: {integrity: sha512-1HGo9a6/ikgOMrTrWL/WiN9N8GSVYpuRQO5kjstAq4CvV59bjqnh7TbdXGQ4vxLD3xlSjfBjq5t1SOELePsLnA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/node-config-provider@3.1.12:
+    resolution: {integrity: sha512-O9LVEu5J/u/FuNlZs+L7Ikn3lz7VB9hb0GtPT9MQeiBmtK8RSY3ULmsZgXhe6VAlgTw0YO+paQx4p8xdbs43vQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/property-provider': 3.1.11
+      '@smithy/shared-ini-file-loader': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/node-http-handler@3.3.2:
+    resolution: {integrity: sha512-t4ng1DAd527vlxvOfKFYEe6/QFBcsj7WpNlWTyjorwXXcKw3XlltBGbyHfSJ24QT84nF+agDha9tNYpzmSRZPA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/abort-controller': 3.1.9
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/querystring-builder': 3.0.11
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/property-provider@3.1.11:
+    resolution: {integrity: sha512-I/+TMc4XTQ3QAjXfOcUWbSS073oOEAxgx4aZy8jHaf8JQnRkq2SZWw8+PfDtBvLUjcGMdxl+YwtzWe6i5uhL/A==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/protocol-http@4.1.8:
+    resolution: {integrity: sha512-hmgIAVyxw1LySOwkgMIUN0kjN8TG9Nc85LJeEmEE/cNEe2rkHDUWhnJf2gxcSRFLWsyqWsrZGw40ROjUogg+Iw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/querystring-builder@3.0.11:
+    resolution: {integrity: sha512-u+5HV/9uJaeLj5XTb6+IEF/dokWWkEqJ0XiaRRogyREmKGUgZnNecLucADLdauWFKUNbQfulHFEZEdjwEBjXRg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      '@smithy/util-uri-escape': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/querystring-parser@3.0.11:
+    resolution: {integrity: sha512-Je3kFvCsFMnso1ilPwA7GtlbPaTixa3WwC+K21kmMZHsBEOZYQaqxcMqeFFoU7/slFjKDIpiiPydvdJm8Q/MCw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/service-error-classification@3.0.11:
+    resolution: {integrity: sha512-QnYDPkyewrJzCyaeI2Rmp7pDwbUETe+hU8ADkXmgNusO1bgHBH7ovXJiYmba8t0fNfJx75fE8dlM6SEmZxheog==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+    dev: false
+
+  /@smithy/shared-ini-file-loader@3.1.12:
+    resolution: {integrity: sha512-1xKSGI+U9KKdbG2qDvIR9dGrw3CNx+baqJfyr0igKEpjbHL5stsqAesYBzHChYHlelWtb87VnLWlhvfCz13H8Q==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/signature-v4@4.2.4:
+    resolution: {integrity: sha512-5JWeMQYg81TgU4cG+OexAWdvDTs5JDdbEZx+Qr1iPbvo91QFGzjy0IkXAKaXUHqmKUJgSHK0ZxnCkgZpzkeNTA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/is-array-buffer': 3.0.0
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      '@smithy/util-hex-encoding': 3.0.0
+      '@smithy/util-middleware': 3.0.11
+      '@smithy/util-uri-escape': 3.0.0
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/smithy-client@3.5.0:
+    resolution: {integrity: sha512-Y8FeOa7gbDfCWf7njrkoRATPa5eNLUEjlJS5z5rXatYuGkCb80LbHcu8AQR8qgAZZaNHCLyo2N+pxPsV7l+ivg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/core': 2.5.5
+      '@smithy/middleware-endpoint': 3.2.5
+      '@smithy/middleware-stack': 3.0.11
+      '@smithy/protocol-http': 4.1.8
+      '@smithy/types': 3.7.2
+      '@smithy/util-stream': 3.3.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/types@3.7.2:
+    resolution: {integrity: sha512-bNwBYYmN8Eh9RyjS1p2gW6MIhSO2rl7X9QeLM8iTdcGRP+eDiIWDt66c9IysCc22gefKszZv+ubV9qZc7hdESg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/url-parser@3.0.11:
+    resolution: {integrity: sha512-TmlqXkSk8ZPhfc+SQutjmFr5FjC0av3GZP4B/10caK1SbRwe/v+Wzu/R6xEKxoNqL+8nY18s1byiy6HqPG37Aw==}
+    dependencies:
+      '@smithy/querystring-parser': 3.0.11
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-base64@3.0.0:
+    resolution: {integrity: sha512-Kxvoh5Qtt0CDsfajiZOCpJxgtPHXOKwmM+Zy4waD43UoEMA+qPxxa98aE/7ZhdnBFZFXMOiBR5xbcaMhLtznQQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/util-buffer-from': 3.0.0
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-body-length-browser@3.0.0:
+    resolution: {integrity: sha512-cbjJs2A1mLYmqmyVl80uoLTJhAcfzMOyPgjwAYusWKMdLeNtzmMz9YxNl3/jRLoxSS3wkqkf0jwNdtXWtyEBaQ==}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-body-length-node@3.0.0:
+    resolution: {integrity: sha512-Tj7pZ4bUloNUP6PzwhN7K386tmSmEET9QtQg0TgdNOnxhZvCssHji+oZTUIuzxECRfG8rdm2PMw2WCFs6eIYkA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-buffer-from@2.2.0:
+    resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      '@smithy/types': 1.2.0
+      '@smithy/is-array-buffer': 2.2.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-buffer-from@3.0.0:
+    resolution: {integrity: sha512-aEOHCgq5RWFbP+UDPvPot26EJHjOC+bRgse5A8V3FSShqd5E5UN4qc7zkwsvJPPAVsf73QwYcHN1/gt/rtLwQA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/is-array-buffer': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-config-provider@3.0.0:
+    resolution: {integrity: sha512-pbjk4s0fwq3Di/ANL+rCvJMKM5bzAQdE5S/6RL5NXgMExFAi6UgQMPOm5yPaIWPpr+EOXKXRonJ3FoxKf4mCJQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-defaults-mode-browser@3.0.30:
+    resolution: {integrity: sha512-nLuGmgfcr0gzm64pqF2UT4SGWVG8UGviAdayDlVzJPNa6Z4lqvpDzdRXmLxtOdEjVlTOEdpZ9dd3ZMMu488mzg==}
+    engines: {node: '>= 10.0.0'}
+    dependencies:
+      '@smithy/property-provider': 3.1.11
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
+      bowser: 2.11.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-defaults-mode-node@3.0.30:
+    resolution: {integrity: sha512-OD63eWoH68vp75mYcfYyuVH+p7Li/mY4sYOROnauDrtObo1cS4uWfsy/zhOTW8F8ZPxQC1ZXZKVxoxvMGUv2Ow==}
+    engines: {node: '>= 10.0.0'}
+    dependencies:
+      '@smithy/config-resolver': 3.0.13
+      '@smithy/credential-provider-imds': 3.2.8
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/property-provider': 3.1.11
+      '@smithy/smithy-client': 3.5.0
+      '@smithy/types': 3.7.2
       tslib: 2.6.2
     dev: false
 
-  /@smithy/types@1.2.0:
-    resolution: {integrity: sha512-z1r00TvBqF3dh4aHhya7nz1HhvCg4TRmw51fjMrh5do3h+ngSstt/yKlNbHeb9QxJmFbmN8KEVSWgb1bRvfEoA==}
+  /@smithy/util-endpoints@2.1.7:
+    resolution: {integrity: sha512-tSfcqKcN/Oo2STEYCABVuKgJ76nyyr6skGl9t15hs+YaiU06sgMkN7QYjo0BbVw+KT26zok3IzbdSOksQ4YzVw==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/node-config-provider': 3.1.12
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-hex-encoding@3.0.0:
+    resolution: {integrity: sha512-eFndh1WEK5YMUYvy3lPlVmYY/fZcQE1D8oSf41Id2vCeIkKJXPcYDCZD+4+xViI6b1XSd7tE+s5AmXzz5ilabQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-middleware@3.0.11:
+    resolution: {integrity: sha512-dWpyc1e1R6VoXrwLoLDd57U1z6CwNSdkM69Ie4+6uYh2GC7Vg51Qtan7ITzczuVpqezdDTKJGJB95fFvvjU/ow==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-retry@3.0.11:
+    resolution: {integrity: sha512-hJUC6W7A3DQgaee3Hp9ZFcOxVDZzmBIRBPlUAk8/fSOEl7pE/aX7Dci0JycNOnm9Mfr0KV2XjIlUOcGWXQUdVQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/service-error-classification': 3.0.11
+      '@smithy/types': 3.7.2
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-stream@3.3.2:
+    resolution: {integrity: sha512-sInAqdiVeisUGYAv/FrXpmJ0b4WTFmciTRqzhb7wVuem9BHvhIG7tpiYHLDWrl2stOokNZpTTGqz3mzB2qFwXg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/fetch-http-handler': 4.1.2
+      '@smithy/node-http-handler': 3.3.2
+      '@smithy/types': 3.7.2
+      '@smithy/util-base64': 3.0.0
+      '@smithy/util-buffer-from': 3.0.0
+      '@smithy/util-hex-encoding': 3.0.0
+      '@smithy/util-utf8': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-uri-escape@3.0.0:
+    resolution: {integrity: sha512-LqR7qYLgZTD7nWLBecUi4aqolw8Mhza9ArpNEQ881MJJIU2sE5iHCK6TdyqqzcDLy0OPe10IY4T8ctVdtynubg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-utf8@2.3.0:
+    resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==}
     engines: {node: '>=14.0.0'}
     dependencies:
+      '@smithy/util-buffer-from': 2.2.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-utf8@3.0.0:
+    resolution: {integrity: sha512-rUeT12bxFnplYDe815GXbq/oixEGHfRFFtcTF3YdDi/JaENIM6aSYYLJydG83UNzLXeRI5K8abYd/8Sp/QM0kA==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/util-buffer-from': 3.0.0
+      tslib: 2.6.2
+    dev: false
+
+  /@smithy/util-waiter@3.2.0:
+    resolution: {integrity: sha512-PpjSboaDUE6yl+1qlg3Si57++e84oXdWGbuFUSAciXsVfEZJJJupR2Nb0QuXHiunt2vGR+1PTizOMvnUPaG2Qg==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      '@smithy/abort-controller': 3.1.9
+      '@smithy/types': 3.7.2
       tslib: 2.6.2
     dev: false
 
@@ -6131,8 +6269,8 @@ packages:
     resolution: {integrity: sha512-VhXlQgj9ioXCqGstD37E/HBeqEGV/qOD/kmbVG8h5xKBYvM1L3lR1Zn4555cQ8GkYbJa8aJSipLPndE1k6zK2w==}
     dev: false
 
-  /fast-xml-parser@4.1.2:
-    resolution: {integrity: sha512-CDYeykkle1LiA/uqQyNwYpFbyF6Axec6YapmpUP+/RHWIoR1zKjocdvNaTsxCxZzQ6v9MLXaSYm9Qq0thv0DHg==}
+  /fast-xml-parser@4.4.1:
+    resolution: {integrity: sha512-xkjOecfnKGkSsOwtZ5Pz7Us/T6mrbPQrq0nh+aCO5V9nk5NLWmasAHumTKjiPJPWANe+kAZ84Jc8ooJkzZ88Sw==}
     hasBin: true
     dependencies:
       strnum: 1.0.5
diff --git a/plugin-server/src/cdp/cdp-consumers.ts b/plugin-server/src/cdp/cdp-consumers.ts
index dbbd163c72ae8..f738b559a0523 100644
--- a/plugin-server/src/cdp/cdp-consumers.ts
+++ b/plugin-server/src/cdp/cdp-consumers.ts
@@ -28,7 +28,7 @@ import { createKafkaProducerWrapper } from '../utils/db/hub'
 import { KafkaProducerWrapper } from '../utils/db/kafka-producer-wrapper'
 import { safeClickhouseString } from '../utils/db/utils'
 import { status } from '../utils/status'
-import { castTimestampOrNow } from '../utils/utils'
+import { castTimestampOrNow, UUIDT } from '../utils/utils'
 import { RustyHook } from '../worker/rusty-hook'
 import { FetchExecutor } from './fetch-executor'
 import { GroupsManager } from './groups-manager'
@@ -43,7 +43,9 @@ import {
     HogFunctionInvocationResult,
     HogFunctionInvocationSerialized,
     HogFunctionInvocationSerializedCompressed,
+    HogFunctionLogEntrySerialized,
     HogFunctionMessageToProduce,
+    HogFunctionType,
     HogHooksFetchResponse,
 } from './types'
 import {
@@ -199,6 +201,24 @@ abstract class CdpConsumerBase {
         })
     }
 
+    protected logFilteringError(item: HogFunctionType, error: string) {
+        const logEntry: HogFunctionLogEntrySerialized = {
+            team_id: item.team_id,
+            log_source: 'hog_function',
+            log_source_id: item.id,
+            instance_id: new UUIDT().toString(), // random UUID, like it would be for an invocation
+            timestamp: castTimestampOrNow(null, TimestampFormat.ClickHouse),
+            level: 'error',
+            message: error,
+        }
+
+        this.messagesToProduce.push({
+            topic: KAFKA_LOG_ENTRIES,
+            value: logEntry,
+            key: logEntry.instance_id,
+        })
+    }
+
     // NOTE: These will be removed once we are only on Cyclotron
     protected async queueInvocationsToKafka(invocation: HogFunctionInvocation[]) {
         await Promise.all(
@@ -479,7 +499,7 @@ export class CdpProcessedEventsConsumer extends CdpConsumerBase {
                         })
                     )
 
-                    erroredFunctions.forEach((item) =>
+                    erroredFunctions.forEach(([item, error]) => {
                         this.produceAppMetric({
                             team_id: item.team_id,
                             app_source_id: item.id,
@@ -487,7 +507,8 @@ export class CdpProcessedEventsConsumer extends CdpConsumerBase {
                             metric_name: 'filtering_failed',
                             count: 1,
                         })
-                    )
+                        this.logFilteringError(item, error)
+                    })
                 })
 
                 const states = await this.hogWatcher.getStates(possibleInvocations.map((x) => x.hogFunction.id))
diff --git a/plugin-server/src/cdp/hog-executor.ts b/plugin-server/src/cdp/hog-executor.ts
index 15e147f022b7f..631f8c8438444 100644
--- a/plugin-server/src/cdp/hog-executor.ts
+++ b/plugin-server/src/cdp/hog-executor.ts
@@ -110,17 +110,17 @@ export class HogExecutor {
         this.telemetryMatcher = buildIntegerMatcher(this.hub.CDP_HOG_FILTERS_TELEMETRY_TEAMS, true)
     }
 
-    findMatchingFunctions(event: HogFunctionInvocationGlobals): {
+    findMatchingFunctions(globals: HogFunctionInvocationGlobals): {
         matchingFunctions: HogFunctionType[]
         nonMatchingFunctions: HogFunctionType[]
-        erroredFunctions: HogFunctionType[]
+        erroredFunctions: [HogFunctionType, string][]
     } {
-        const allFunctionsForTeam = this.hogFunctionManager.getTeamHogDestinations(event.project.id)
-        const filtersGlobals = convertToHogFunctionFilterGlobal(event)
+        const allFunctionsForTeam = this.hogFunctionManager.getTeamHogDestinations(globals.project.id)
+        const filtersGlobals = convertToHogFunctionFilterGlobal(globals)
 
         const nonMatchingFunctions: HogFunctionType[] = []
         const matchingFunctions: HogFunctionType[] = []
-        const erroredFunctions: HogFunctionType[] = []
+        const erroredFunctions: [HogFunctionType, string][] = []
 
         // Filter all functions based on the invocation
         allFunctionsForTeam.forEach((hogFunction) => {
@@ -143,7 +143,10 @@ export class HogExecutor {
                             error: filterResult.error.message,
                             result: filterResult,
                         })
-                        erroredFunctions.push(hogFunction)
+                        erroredFunctions.push([
+                            hogFunction,
+                            `Error filtering event ${globals.event.uuid}: ${filterResult.error.message}`,
+                        ])
                         return
                     }
                 } catch (error) {
@@ -153,7 +156,10 @@ export class HogExecutor {
                         teamId: hogFunction.team_id,
                         error: error.message,
                     })
-                    erroredFunctions.push(hogFunction)
+                    erroredFunctions.push([
+                        hogFunction,
+                        `Error filtering event ${globals.event.uuid}: ${error.message}`,
+                    ])
                     return
                 } finally {
                     const duration = performance.now() - start
@@ -165,7 +171,7 @@ export class HogExecutor {
                             hogFunctionName: hogFunction.name,
                             teamId: hogFunction.team_id,
                             duration,
-                            eventId: event.event.uuid,
+                            eventId: globals.event.uuid,
                         })
                     }
                 }
diff --git a/plugin-server/src/cdp/types.ts b/plugin-server/src/cdp/types.ts
index 8a675e605e017..e9d506a7a7823 100644
--- a/plugin-server/src/cdp/types.ts
+++ b/plugin-server/src/cdp/types.ts
@@ -272,6 +272,7 @@ export type HogFunctionInputSchemaType = {
     integration?: string
     integration_key?: string
     integration_field?: 'slack_channel'
+    requiredScopes?: string
 }
 
 export type HogFunctionTypeType = 'destination' | 'email' | 'sms' | 'push' | 'activity' | 'alert' | 'broadcast'
diff --git a/plugin-server/src/main/ingestion-queues/session-recording/process-event.ts b/plugin-server/src/main/ingestion-queues/session-recording/process-event.ts
index 81cc72f3c3eb9..97903b8548569 100644
--- a/plugin-server/src/main/ingestion-queues/session-recording/process-event.ts
+++ b/plugin-server/src/main/ingestion-queues/session-recording/process-event.ts
@@ -32,6 +32,7 @@ export interface SummarizedSessionRecordingEvent {
     distinct_id: string
     session_id: string
     first_url: string | null
+    urls: string[]
     click_count: number
     keypress_count: number
     mouse_activity_count: number
@@ -255,7 +256,7 @@ export const createSessionReplayEvent = (
     session_id: string,
     events: RRWebEvent[],
     snapshot_source: string | null
-): { event: SummarizedSessionRecordingEvent; warnings: string[] } => {
+): { event: SummarizedSessionRecordingEvent } => {
     const timestamps = getTimestampsFrom(events)
 
     // but every event where chunk index = 0 must have an eventsSummary
@@ -268,15 +269,14 @@ export const createSessionReplayEvent = (
         throw new Error('ignoring an empty session recording event')
     }
 
-    const warnings: string[] = []
-
     let clickCount = 0
     let keypressCount = 0
     let mouseActivity = 0
     let consoleLogCount = 0
     let consoleWarnCount = 0
     let consoleErrorCount = 0
-    let url: string | null = null
+    const urls: Set<string> = new Set()
+
     events.forEach((event) => {
         if (event.type === RRWebEventType.IncrementalSnapshot) {
             if (isClick(event)) {
@@ -291,8 +291,8 @@ export const createSessionReplayEvent = (
         }
 
         const eventUrl: string | undefined = hrefFrom(event)
-        if (url === null && eventUrl) {
-            url = eventUrl
+        if (eventUrl) {
+            urls.add(eventUrl)
         }
 
         if (event.type === RRWebEventType.Plugin && event.data?.plugin === 'rrweb/console@1') {
@@ -305,13 +305,10 @@ export const createSessionReplayEvent = (
                 consoleErrorCount += 1
             }
         }
-
-        if (event.type === RRWebEventType.Custom && event.data?.tag === 'Message too large') {
-            warnings.push('replay_message_too_large')
-        }
     })
 
     const activeTime = activeMilliseconds(events)
+    const urlArray = Array.from(urls)
 
     // NB forces types to be correct e.g. by truncating or rounding
     // to ensure we don't send floats when we should send an integer
@@ -325,7 +322,8 @@ export const createSessionReplayEvent = (
         click_count: Math.trunc(clickCount),
         keypress_count: Math.trunc(keypressCount),
         mouse_activity_count: Math.trunc(mouseActivity),
-        first_url: url,
+        first_url: urlArray.length ? urlArray[0] : null,
+        urls: urlArray,
         active_milliseconds: Math.round(activeTime),
         console_log_count: Math.trunc(consoleLogCount),
         console_warn_count: Math.trunc(consoleWarnCount),
@@ -336,5 +334,5 @@ export const createSessionReplayEvent = (
         snapshot_source: snapshot_source || 'web',
     }
 
-    return { event: data, warnings }
+    return { event: data }
 }
diff --git a/plugin-server/src/main/ingestion-queues/session-recording/services/replay-events-ingester.ts b/plugin-server/src/main/ingestion-queues/session-recording/services/replay-events-ingester.ts
index 09db8ac9731b6..18d0d578cdaab 100644
--- a/plugin-server/src/main/ingestion-queues/session-recording/services/replay-events-ingester.ts
+++ b/plugin-server/src/main/ingestion-queues/session-recording/services/replay-events-ingester.ts
@@ -71,9 +71,9 @@ export class ReplayEventsIngester {
                 status.error('🔁', '[replay-events] main_loop_error', { error })
 
                 if (error?.isRetriable) {
-                    // We assume the if the error is retriable, then we
+                    // We assume that if the error is retriable, then we
                     // are probably in a state where e.g. Kafka is down
-                    // temporarily and we would rather simply throw and
+                    // temporarily, and we would rather simply throw and
                     // have the process restarted.
                     throw error
                 }
@@ -124,7 +124,7 @@ export class ReplayEventsIngester {
         try {
             const rrwebEvents = Object.values(event.eventsByWindowId).reduce((acc, val) => acc.concat(val), [])
 
-            const { event: replayRecord, warnings } = createSessionReplayEvent(
+            const { event: replayRecord } = createSessionReplayEvent(
                 randomUUID(),
                 event.team_id,
                 event.distinct_id,
@@ -154,22 +154,6 @@ export class ReplayEventsIngester {
                         return drop('invalid_timestamp')
                     }
                 }
-
-                await Promise.allSettled(
-                    warnings.map(async (warning) => {
-                        await captureIngestionWarning(
-                            new KafkaProducerWrapper(this.producer),
-                            event.team_id,
-                            warning,
-                            {
-                                replayRecord,
-                                timestamp: replayRecord.first_timestamp,
-                                processingTimestamp: DateTime.now().toISO(),
-                            },
-                            { key: event.session_id }
-                        )
-                    })
-                )
             } catch (e) {
                 captureException(e, {
                     extra: {
diff --git a/plugin-server/src/types.ts b/plugin-server/src/types.ts
index e8682da3b337b..47ac3764a3528 100644
--- a/plugin-server/src/types.ts
+++ b/plugin-server/src/types.ts
@@ -1103,6 +1103,7 @@ export interface EventDefinitionType {
     volume_30_day: number | null
     query_usage_30_day: number | null
     team_id: number
+    project_id: number | null
     last_seen_at: string // DateTime
     created_at: string // DateTime
 }
@@ -1142,6 +1143,7 @@ export interface PropertyDefinitionType {
     volume_30_day: number | null
     query_usage_30_day: number | null
     team_id: number
+    project_id: number | null
     property_type?: PropertyType
     type: PropertyDefinitionTypeEnum
     group_type_index: number | null
@@ -1152,6 +1154,7 @@ export interface EventPropertyType {
     event: string
     property: string
     team_id: number
+    project_id: number | null
 }
 
 export type PluginFunction = 'onEvent' | 'processEvent' | 'pluginTask'
diff --git a/plugin-server/src/worker/ingestion/event-pipeline/populateTeamDataStep.ts b/plugin-server/src/worker/ingestion/event-pipeline/populateTeamDataStep.ts
index de63033393f46..042eb197122a3 100644
--- a/plugin-server/src/worker/ingestion/event-pipeline/populateTeamDataStep.ts
+++ b/plugin-server/src/worker/ingestion/event-pipeline/populateTeamDataStep.ts
@@ -2,6 +2,7 @@ import { PluginEvent } from '@posthog/plugin-scaffold'
 
 import { eventDroppedCounter } from '../../../main/ingestion-queues/metrics'
 import { PipelineEvent } from '../../../types'
+import { sanitizeString } from '../../../utils/db/utils'
 import { UUID } from '../../../utils/utils'
 import { captureIngestionWarning } from '../utils'
 import { tokenOrTeamPresentCounter } from './metrics'
@@ -42,6 +43,9 @@ export async function populateTeamDataStep(
     } else if (event.team_id) {
         team = await runner.hub.teamManager.fetchTeam(event.team_id)
     } else if (event.token) {
+        // HACK: we've had null bytes end up in the token in the ingest pipeline before, for some reason. We should try to
+        // prevent this generally, but if it happens, we should at least simply fail to lookup the team, rather than crashing
+        event.token = sanitizeString(event.token)
         team = await runner.hub.teamManager.getTeamByToken(event.token)
     }
 
diff --git a/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts b/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts
index 4bd6eb339c5cf..c559a4240fca4 100644
--- a/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts
+++ b/plugin-server/tests/cdp/cdp-processed-events-consumer.test.ts
@@ -333,5 +333,56 @@ describe('CDP Processed Events Consumer', () => {
                 ])
             })
         })
+
+        describe('filtering errors', () => {
+            let globals: HogFunctionInvocationGlobals
+
+            beforeEach(() => {
+                globals = createHogExecutionGlobals({
+                    project: {
+                        id: team.id,
+                    } as any,
+                    event: {
+                        uuid: 'b3a1fe86-b10c-43cc-acaf-d208977608d0',
+                        event: '$pageview',
+                        properties: {
+                            $current_url: 'https://posthog.com',
+                            $lib_version: '1.0.0',
+                        },
+                    } as any,
+                })
+            })
+
+            it('should filter out functions that error while filtering', async () => {
+                const erroringFunction = await insertHogFunction({
+                    ...HOG_EXAMPLES.input_printer,
+                    ...HOG_INPUTS_EXAMPLES.secret_inputs,
+                    ...HOG_FILTERS_EXAMPLES.broken_filters,
+                })
+                await processor.processBatch([globals])
+                expect(decodeAllKafkaMessages()).toMatchObject([
+                    {
+                        key: expect.any(String),
+                        topic: 'clickhouse_app_metrics2_test',
+                        value: {
+                            app_source: 'hog_function',
+                            app_source_id: erroringFunction.id,
+                            count: 1,
+                            metric_kind: 'other',
+                            metric_name: 'filtering_failed',
+                            team_id: 2,
+                            timestamp: expect.any(String),
+                        },
+                    },
+                    {
+                        topic: 'log_entries_test',
+                        value: {
+                            message:
+                                'Error filtering event b3a1fe86-b10c-43cc-acaf-d208977608d0: Invalid HogQL bytecode, stack is empty, can not pop',
+                        },
+                    },
+                ])
+            })
+        })
     })
 })
diff --git a/plugin-server/tests/main/ingestion-queues/session-recording/process-event.test.ts b/plugin-server/tests/main/ingestion-queues/session-recording/process-event.test.ts
index 23c89d7c64555..60bfba880a647 100644
--- a/plugin-server/tests/main/ingestion-queues/session-recording/process-event.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/session-recording/process-event.test.ts
@@ -32,8 +32,8 @@ describe('session recording process event', () => {
             | 'event_count'
             | 'message_count'
             | 'snapshot_source'
+            | 'urls'
         >
-        expectedWarnings: string[]
     }[] = [
         {
             testDescription: 'click and mouse counts are detected',
@@ -68,8 +68,8 @@ describe('session recording process event', () => {
                 event_count: 6,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: [],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'keyboard press is detected',
@@ -92,8 +92,8 @@ describe('session recording process event', () => {
                 event_count: 1,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: [],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'console log entries are counted',
@@ -181,8 +181,8 @@ describe('session recording process event', () => {
                 event_count: 11,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: [],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'url can be detected in meta event',
@@ -219,8 +219,8 @@ describe('session recording process event', () => {
                 event_count: 2,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: ['http://127.0.0.1:8000/the/url'],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'first url detection takes the first url whether meta url or payload url',
@@ -261,8 +261,8 @@ describe('session recording process event', () => {
                 event_count: 2,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: ['http://127.0.0.1:8000/home', 'http://127.0.0.1:8000/second/url'],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'first url detection can use payload url',
@@ -307,8 +307,8 @@ describe('session recording process event', () => {
                 event_count: 2,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: ['http://127.0.0.1:8000/my-spa'],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'negative timestamps are not included when picking timestamps',
@@ -336,8 +336,8 @@ describe('session recording process event', () => {
                 event_count: 3,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: [],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'overlapping windows are summed separately for activity',
@@ -368,8 +368,8 @@ describe('session recording process event', () => {
                 event_count: 6,
                 message_count: 1,
                 snapshot_source: 'web',
+                urls: [],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'mobile snapshot source is stored',
@@ -392,8 +392,8 @@ describe('session recording process event', () => {
                 mouse_activity_count: 1,
                 size: 82,
                 snapshot_source: 'mobile',
+                urls: [],
             },
-            expectedWarnings: [],
         },
         {
             testDescription: 'message too large warning is reported',
@@ -419,15 +419,83 @@ describe('session recording process event', () => {
                 mouse_activity_count: 1,
                 size: 169,
                 snapshot_source: 'web',
+                urls: [],
+            },
+        },
+        {
+            testDescription: 'urls array is deduplicated',
+            snapshotData: {
+                events_summary: [
+                    {
+                        timestamp: 1682449093469,
+                        type: 5,
+                        data: {
+                            payload: {
+                                // we don't read just any URL
+                                'the-page-url': 'http://127.0.0.1:8000/not/included',
+                            },
+                        },
+                        windowId: '1',
+                    },
+                    {
+                        timestamp: 1682449093693,
+                        type: 5,
+                        data: {
+                            payload: {
+                                // matches href nested in payload
+                                href: 'http://127.0.0.1:8000/my-spa',
+                            },
+                        },
+                        windowId: '1',
+                    },
+                    {
+                        timestamp: 1682449093693,
+                        type: 5,
+                        data: {
+                            payload: {
+                                // matches href nested in payload
+                                href: 'http://127.0.0.1:8000/my-spa',
+                            },
+                        },
+                        windowId: '1',
+                    },
+                    {
+                        timestamp: 1682449093693,
+                        type: 5,
+                        data: {
+                            payload: {
+                                // matches href nested in payload
+                                href: 'http://127.0.0.1:8000/my-spa/1',
+                            },
+                        },
+                        windowId: '1',
+                    },
+                ],
+            },
+            expected: {
+                click_count: 0,
+                keypress_count: 0,
+                mouse_activity_count: 0,
+                first_url: 'http://127.0.0.1:8000/my-spa',
+                first_timestamp: '2023-04-25 18:58:13.469',
+                last_timestamp: '2023-04-25 18:58:13.693',
+                active_milliseconds: 0, // no data.source, so no activity
+                console_log_count: 0,
+                console_warn_count: 0,
+                console_error_count: 0,
+                size: 461,
+                event_count: 4,
+                message_count: 1,
+                snapshot_source: 'web',
+                urls: ['http://127.0.0.1:8000/my-spa', 'http://127.0.0.1:8000/my-spa/1'],
             },
-            expectedWarnings: ['replay_message_too_large'],
         },
     ]
 
     it.each(sessionReplayEventTestCases)(
         'session replay event generation - $testDescription',
-        ({ snapshotData, snapshotSource, expected, expectedWarnings }) => {
-            const { event: data, warnings } = createSessionReplayEvent(
+        ({ snapshotData, snapshotSource, expected }) => {
+            const { event: data } = createSessionReplayEvent(
                 'some-id',
                 12345,
                 '5AzhubH8uMghFHxXq0phfs14JOjH6SA2Ftr1dzXj7U4',
@@ -436,8 +504,6 @@ describe('session recording process event', () => {
                 snapshotSource || null
             )
 
-            expect(warnings).toStrictEqual(expectedWarnings)
-
             const expectedEvent: SummarizedSessionRecordingEvent = {
                 distinct_id: '5AzhubH8uMghFHxXq0phfs14JOjH6SA2Ftr1dzXj7U4',
                 session_id: 'abcf-efg',
diff --git a/plugin-server/tests/main/ingestion-queues/session-recording/services/replay-events-ingester.test.ts b/plugin-server/tests/main/ingestion-queues/session-recording/services/replay-events-ingester.test.ts
index 7da9cf2bda001..e9e94583bc4c6 100644
--- a/plugin-server/tests/main/ingestion-queues/session-recording/services/replay-events-ingester.test.ts
+++ b/plugin-server/tests/main/ingestion-queues/session-recording/services/replay-events-ingester.test.ts
@@ -12,11 +12,18 @@ import { castTimestampOrNow } from '../../../../../src/utils/utils'
 jest.mock('../../../../../src/utils/status')
 jest.mock('../../../../../src/kafka/producer')
 
-const makeIncomingMessage = (source: string | null, timestamp: number): IncomingRecordingMessage => {
+const makeIncomingMessage = (
+    source: string | null,
+    timestamp: number,
+    extraWindowedEvents?: Record<string, Record<string, any>[]>
+): IncomingRecordingMessage => {
     return {
         distinct_id: '',
         eventsRange: { start: timestamp, end: timestamp },
-        eventsByWindowId: { '': [{ data: { any: 'thing' }, type: 2, timestamp: timestamp }] },
+        eventsByWindowId: {
+            '': [{ data: { any: 'thing' }, type: 2, timestamp: timestamp }],
+            ...(extraWindowedEvents || {}),
+        },
         metadata: {
             lowOffset: 0,
             highOffset: 0,
@@ -105,6 +112,7 @@ describe('replay events ingester', () => {
             snapshot_source: "mickey's fun house",
             team_id: 0,
             uuid: expect.any(String),
+            urls: [],
         })
     })
 
@@ -138,6 +146,50 @@ describe('replay events ingester', () => {
             snapshot_source: 'web',
             team_id: 0,
             uuid: expect.any(String),
+            urls: [],
+        })
+    })
+
+    test('it adds URLs', async () => {
+        const ts = new Date().getTime()
+        await ingester.consume(
+            makeIncomingMessage("mickey's fun house", ts, {
+                anotherwindow: [
+                    { data: { href: 'thing' }, type: 2, timestamp: ts },
+                    // should be deduplicated
+                    { data: { href: 'thing' }, type: 2, timestamp: ts },
+                    { data: { href: 'thing2' }, type: 2, timestamp: ts },
+                ],
+            })
+        )
+
+        expect(jest.mocked(status.debug).mock.calls).toEqual([])
+        expect(jest.mocked(produce).mock.calls).toHaveLength(1)
+        expect(jest.mocked(produce).mock.calls[0]).toHaveLength(1)
+        const call = jest.mocked(produce).mock.calls[0][0]
+        expect(call.topic).toEqual('clickhouse_session_replay_events_test')
+        // call.value is a Buffer convert it to a string
+        const value = call.value ? JSON.parse(call.value.toString()) : null
+        expect(value).toEqual({
+            active_milliseconds: 0,
+            click_count: 0,
+            console_error_count: 0,
+            console_log_count: 0,
+            console_warn_count: 0,
+            distinct_id: '',
+            event_count: 4,
+            first_timestamp: expect.any(String),
+            first_url: 'thing',
+            keypress_count: 0,
+            last_timestamp: expect.any(String),
+            message_count: 1,
+            mouse_activity_count: 0,
+            session_id: '',
+            size: 245,
+            snapshot_source: "mickey's fun house",
+            team_id: 0,
+            uuid: expect.any(String),
+            urls: ['thing', 'thing2'],
         })
     })
 })
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 46b9d8ad2f29c..b753b5863fb37 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -53,8 +53,8 @@ dependencies:
     specifier: 4.6.0
     version: 4.6.0(monaco-editor@0.49.0)(react-dom@18.2.0)(react@18.2.0)
   '@posthog/hogvm':
-    specifier: ^1.0.61
-    version: 1.0.61(luxon@3.5.0)
+    specifier: ^1.0.64
+    version: 1.0.64(luxon@3.5.0)
   '@posthog/icons':
     specifier: 0.9.2
     version: 0.9.2(react-dom@18.2.0)(react@18.2.0)
@@ -217,6 +217,9 @@ dependencies:
   fast-deep-equal:
     specifier: ^3.1.3
     version: 3.1.3
+  fastpriorityqueue:
+    specifier: ^0.7.5
+    version: 0.7.5
   fflate:
     specifier: ^0.7.4
     version: 0.7.4
@@ -302,8 +305,8 @@ dependencies:
     specifier: ^9.3.0
     version: 9.3.0(postcss@8.4.31)
   posthog-js:
-    specifier: 1.194.3
-    version: 1.194.3
+    specifier: 1.201.1
+    version: 1.201.1
   posthog-js-lite:
     specifier: 3.0.0
     version: 3.0.0
@@ -605,6 +608,9 @@ devDependencies:
   babel-plugin-import:
     specifier: ^1.13.0
     version: 1.13.8
+  caniuse-lite:
+    specifier: ^1.0.30001687
+    version: 1.0.30001687
   concurrently:
     specifier: ^5.3.0
     version: 5.3.0
@@ -4281,8 +4287,8 @@ packages:
       react: 18.2.0
     dev: true
 
-  /@emotion/use-insertion-effect-with-fallbacks@1.1.0(react@18.2.0):
-    resolution: {integrity: sha512-+wBOcIV5snwGgI2ya3u99D7/FJquOIniQT1IKyDsBmEgwvpxMNeS65Oib7OnE2d2aY+3BU4OiH+0Wchf8yk3Hw==}
+  /@emotion/use-insertion-effect-with-fallbacks@1.2.0(react@18.2.0):
+    resolution: {integrity: sha512-yJMtVdH59sxi/aVJBpk9FQq+OR8ll5GT8oWd57UpeaKEVGab41JWaCFA7FRLoMLloOZF/c/wsPoe+bfGmRKgDg==}
     peerDependencies:
       react: '>=16.8.0'
     dependencies:
@@ -5440,8 +5446,8 @@ packages:
     resolution: {integrity: sha512-50/17A98tWUfQ176raKiOGXuYpLyyVMkxxG6oylzL3BPOlA6ADGdK7EYunSa4I064xerltq9TGXs8HmOk5E+vw==}
     dev: false
 
-  /@posthog/hogvm@1.0.61(luxon@3.5.0):
-    resolution: {integrity: sha512-zCwQp6Zn2F2/QNhd1/0IwpndhElVZ2pzsoh2IOZWapZ+jNo6y/taL3128Uwoiec01IYiPXF8EVYOJP7X4Woj+A==}
+  /@posthog/hogvm@1.0.64(luxon@3.5.0):
+    resolution: {integrity: sha512-s6l5IhrtfLWXapW7Bl/YDvwX7hng9ypmhGul6Tljxu4ea5TBgexowf9+BhIGKo2JIUzyaZbLvDwQpTQopR1qvA==}
     peerDependencies:
       luxon: ^3.4.4
     dependencies:
@@ -7362,7 +7368,7 @@ packages:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0
       react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0
     dependencies:
-      '@emotion/use-insertion-effect-with-fallbacks': 1.1.0(react@18.2.0)
+      '@emotion/use-insertion-effect-with-fallbacks': 1.2.0(react@18.2.0)
       '@storybook/client-logger': 7.6.20
       '@storybook/global': 5.0.0
       memoizerific: 1.11.3
@@ -9632,7 +9638,7 @@ packages:
       postcss: ^8.1.0
     dependencies:
       browserslist: 4.22.2
-      caniuse-lite: 1.0.30001568
+      caniuse-lite: 1.0.30001687
       fraction.js: 4.2.0
       normalize-range: 0.1.2
       picocolors: 1.0.0
@@ -9648,7 +9654,7 @@ packages:
       postcss: ^8.1.0
     dependencies:
       browserslist: 4.22.2
-      caniuse-lite: 1.0.30001568
+      caniuse-lite: 1.0.30001687
       fraction.js: 4.3.7
       normalize-range: 0.1.2
       picocolors: 1.0.0
@@ -10012,7 +10018,7 @@ packages:
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
     dependencies:
-      caniuse-lite: 1.0.30001538
+      caniuse-lite: 1.0.30001687
       electron-to-chromium: 1.4.492
       node-releases: 2.0.13
       update-browserslist-db: 1.0.11(browserslist@4.21.10)
@@ -10022,7 +10028,7 @@ packages:
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
     dependencies:
-      caniuse-lite: 1.0.30001568
+      caniuse-lite: 1.0.30001687
       electron-to-chromium: 1.4.609
       node-releases: 2.0.14
       update-browserslist-db: 1.0.13(browserslist@4.22.2)
@@ -10089,6 +10095,14 @@ packages:
       write-file-atomic: 3.0.3
     dev: true
 
+  /call-bind-apply-helpers@1.0.1:
+    resolution: {integrity: sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+    dev: true
+
   /call-bind@1.0.2:
     resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
     dependencies:
@@ -10112,6 +10126,14 @@ packages:
       get-intrinsic: 1.2.4
       set-function-length: 1.2.2
 
+  /call-bound@1.0.3:
+    resolution: {integrity: sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind-apply-helpers: 1.0.1
+      get-intrinsic: 1.2.6
+    dev: true
+
   /callsites@3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
@@ -10156,16 +10178,13 @@ packages:
     resolution: {integrity: sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==}
     dependencies:
       browserslist: 4.22.2
-      caniuse-lite: 1.0.30001568
+      caniuse-lite: 1.0.30001687
       lodash.memoize: 4.1.2
       lodash.uniq: 4.5.0
     dev: false
 
-  /caniuse-lite@1.0.30001538:
-    resolution: {integrity: sha512-HWJnhnID+0YMtGlzcp3T9drmBJUVDchPJ08tpUGFLs9CYlwWPH2uLgpHn8fND5pCgXVtnGS3H4QR9XLMHVNkHw==}
-
-  /caniuse-lite@1.0.30001568:
-    resolution: {integrity: sha512-vSUkH84HontZJ88MiNrOau1EBrCqEQYgkC5gIySiDlpsm8sGVrhU7Kx4V6h0tnqaHzIHZv08HlJIwPbL4XL9+A==}
+  /caniuse-lite@1.0.30001687:
+    resolution: {integrity: sha512-0S/FDhf4ZiqrTUiQ39dKeUjYRjkv7lOZU1Dgif2rIqrTzX/1wV2hfKu9TOm1IHkdSijfLswxTFzl/cvir+SLSQ==}
 
   /case-anything@2.1.10:
     resolution: {integrity: sha512-JczJwVrCP0jPKh05McyVsuOg6AYosrB9XWZKbQzXeDAm2ClE/PJE/BcrrQrVyGYH7Jg8V/LDupmyL4kFlVsVFQ==}
@@ -11780,6 +11799,15 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
+  /dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind-apply-helpers: 1.0.1
+      es-errors: 1.3.0
+      gopd: 1.2.0
+    dev: true
+
   /duplexify@3.7.1:
     resolution: {integrity: sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==}
     dependencies:
@@ -12000,6 +12028,11 @@ packages:
     dependencies:
       get-intrinsic: 1.2.4
 
+  /es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
   /es-errors@1.3.0:
     resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
     engines: {node: '>= 0.4'}
@@ -12043,6 +12076,13 @@ packages:
     resolution: {integrity: sha512-cXLGjP0c4T3flZJKQSuziYoq7MlT+rnvfZjfp7h+I7K9BNX54kP9nyWvdbwjQ4u1iWbOL4u96fgeZLToQlZC7w==}
     dev: true
 
+  /es-object-atoms@1.0.0:
+    resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+    dev: true
+
   /es-set-tostringtag@2.0.2:
     resolution: {integrity: sha512-BuDyupZt65P9D2D2vA/zqcI3G5xRsklm5N3xCwuiy+/vKy8i0ifdsQP1sLgO4tZDSCaQUSnmC48khknGMV3D2Q==}
     engines: {node: '>= 0.4'}
@@ -12278,7 +12318,7 @@ packages:
       '@mdn/browser-compat-data': 5.3.16
       ast-metadata-inferer: 0.8.0
       browserslist: 4.21.10
-      caniuse-lite: 1.0.30001538
+      caniuse-lite: 1.0.30001687
       eslint: 8.57.0
       find-up: 5.0.0
       lodash.memoize: 4.1.2
@@ -12767,6 +12807,10 @@ packages:
     engines: {node: '>= 4.9.1'}
     dev: true
 
+  /fastpriorityqueue@0.7.5:
+    resolution: {integrity: sha512-3Pa0n9gwy8yIbEsT3m2j/E9DXgWvvjfiZjjqcJ+AdNKTAlVMIuFYrYG5Y3RHEM8O6cwv9hOpOWY/NaMfywoQVA==}
+    dev: false
+
   /fastq@1.13.0:
     resolution: {integrity: sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==}
     dependencies:
@@ -13259,6 +13303,22 @@ packages:
       has-symbols: 1.0.3
       hasown: 2.0.2
 
+  /get-intrinsic@1.2.6:
+    resolution: {integrity: sha512-qxsEs+9A+u85HhllWJJFicJfPDhRmjzoYdl64aMWW9yRIJmSyxdn8IEkuIM530/7T+lv0TIHd8L6Q/ra0tEoeA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind-apply-helpers: 1.0.1
+      dunder-proto: 1.0.1
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.0.0
+      function-bind: 1.1.2
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      math-intrinsics: 1.0.0
+    dev: true
+
   /get-nonce@1.0.1:
     resolution: {integrity: sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==}
     engines: {node: '>=6'}
@@ -13493,6 +13553,11 @@ packages:
     dependencies:
       get-intrinsic: 1.2.2
 
+  /gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
   /graceful-fs@4.2.11:
     resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
 
@@ -13568,6 +13633,11 @@ packages:
     resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==}
     engines: {node: '>= 0.4'}
 
+  /has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
   /has-tostringtag@1.0.0:
     resolution: {integrity: sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==}
     engines: {node: '>= 0.4'}
@@ -14003,7 +14073,7 @@ packages:
       hogan.js: 3.0.2
       htm: 3.1.1
       instantsearch-ui-components: 0.3.0
-      preact: 10.25.1
+      preact: 10.25.2
       qs: 6.9.7
       search-insights: 2.13.0
     dev: false
@@ -15926,6 +15996,11 @@ packages:
     resolution: {integrity: sha512-6qE4B9deFBIa9YSpOc9O0Sgc43zTeVYbgDT5veRKSlB2+ZuHNoVVxA1L/ckMUayV9Ay9y7Z/SZCLcGteW9i7bg==}
     dev: false
 
+  /math-intrinsics@1.0.0:
+    resolution: {integrity: sha512-4MqMiKP90ybymYvsut0CH2g4XWbfLtmlCkXmtmdcDCxNB+mQcu1w/1+L/VD7vi/PSv7X2JYV7SCcR+jiPXnQtA==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
   /mathml-tag-names@2.1.3:
     resolution: {integrity: sha512-APMBEanjybaPzUrfqU0IMU5I0AswKMH7k8OTLs0vvV4KZpExkTkY87nR/zpbuTPj+gARop7aGUbl11pnDfW6xg==}
     dev: true
@@ -16465,6 +16540,11 @@ packages:
     resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==}
     dev: true
 
+  /object-inspect@1.13.3:
+    resolution: {integrity: sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
   /object-is@1.1.5:
     resolution: {integrity: sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==}
     engines: {node: '>= 0.4'}
@@ -17822,12 +17902,12 @@ packages:
     resolution: {integrity: sha512-dyajjnfzZD1tht4N7p7iwf7nBnR1MjVaVu+MKr+7gBgA39bn28wizCIJZztZPtHy4PY0YwtSGgwfBCuG/hnHgA==}
     dev: false
 
-  /posthog-js@1.194.3:
-    resolution: {integrity: sha512-/YFpBMqZzRpywa07QeoaIojdrUDijFajT4gZBSCFUBuZA5BN5xr5S1spsvtpT7E4RjkQSVgRvUngI4W19csgQw==}
+  /posthog-js@1.201.1:
+    resolution: {integrity: sha512-srzbJLIzGp0DirGFhadXE1BDB9JGsfaTKLNX3PWehtVf3TSd4i1nX75hQHJmqrzRkGyMNMArQAuVCQN3aWMn3A==}
     dependencies:
       core-js: 3.39.0
       fflate: 0.4.8
-      preact: 10.25.1
+      preact: 10.25.2
       web-vitals: 4.2.4
     dev: false
 
@@ -17835,8 +17915,8 @@ packages:
     resolution: {integrity: sha512-Q+/tYsFU9r7xoOJ+y/ZTtdVQwTWfzjbiXBDMM/JKUux3+QPP02iUuIoeBQ+Ot6oEDlC+/PGjB/5A3K7KKb7hcw==}
     dev: false
 
-  /preact@10.25.1:
-    resolution: {integrity: sha512-frxeZV2vhQSohQwJ7FvlqC40ze89+8friponWUFeVEkaCfhC6Eu4V0iND5C9CXz8JLndV07QRDeXzH1+Anz5Og==}
+  /preact@10.25.2:
+    resolution: {integrity: sha512-GEts1EH3oMnqdOIeXhlbBSddZ9nrINd070WBOiPO2ous1orrKGUM4SMDbwyjSWD1iMS2dBvaDjAa5qUhz3TXqw==}
     dev: false
 
   /prelude-ls@1.2.1:
@@ -18205,7 +18285,7 @@ packages:
     resolution: {integrity: sha512-EJPeIn0CYrGu+hli1xilKAPXODtJ12T0sP63Ijx2/khC2JtuaN3JyNIpvmnkmaEtha9ocbG4A4cMcr+TvqvwQg==}
     engines: {node: '>=0.6'}
     dependencies:
-      side-channel: 1.0.6
+      side-channel: 1.1.0
     dev: true
 
   /qs@6.9.7:
@@ -18440,7 +18520,7 @@ packages:
       react: '>=15'
     dependencies:
       react: 18.2.0
-      unlayer-types: 1.169.0
+      unlayer-types: 1.182.0
     dev: false
 
   /react-error-boundary@3.1.4(react@18.2.0):
@@ -19607,6 +19687,35 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /side-channel-list@1.0.0:
+    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.3
+    dev: true
+
+  /side-channel-map@1.0.1:
+    resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.3
+      es-errors: 1.3.0
+      get-intrinsic: 1.2.6
+      object-inspect: 1.13.3
+    dev: true
+
+  /side-channel-weakmap@1.0.2:
+    resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.3
+      es-errors: 1.3.0
+      get-intrinsic: 1.2.6
+      object-inspect: 1.13.3
+      side-channel-map: 1.0.1
+    dev: true
+
   /side-channel@1.0.4:
     resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==}
     dependencies:
@@ -19624,6 +19733,17 @@ packages:
       object-inspect: 1.13.1
     dev: true
 
+  /side-channel@1.1.0:
+    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.3
+      side-channel-list: 1.0.0
+      side-channel-map: 1.0.1
+      side-channel-weakmap: 1.0.2
+    dev: true
+
   /signal-exit@3.0.7:
     resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
     dev: true
@@ -20987,8 +21107,8 @@ packages:
     resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==}
     engines: {node: '>= 10.0.0'}
 
-  /unlayer-types@1.169.0:
-    resolution: {integrity: sha512-BXT4C/MzrYIiiEXHOovtquGehX4IXLYKx3qo4SwYGmqmaGMvZLKvt2rDlO+DKUjVnvGHxgre/tAbUl3I5Gnpxg==}
+  /unlayer-types@1.182.0:
+    resolution: {integrity: sha512-x+YSeA7/Wb/znKDtRws8M3Mu6TyKP3d+MddPVX/iUyDPVEOapoPWk0QxjIaNYtWt6troADZdhzgr2EwsZ61HrA==}
     dev: false
 
   /unpipe@1.0.0:
diff --git a/posthog/api/__init__.py b/posthog/api/__init__.py
index bf1db10b864a5..72342189f2764 100644
--- a/posthog/api/__init__.py
+++ b/posthog/api/__init__.py
@@ -2,7 +2,7 @@
 from rest_framework_extensions.routers import NestedRegistryItem
 
 
-from posthog.api import project
+from posthog.api import metalytics, project
 from posthog.api.routing import DefaultRouterPlusPlus
 from posthog.batch_exports import http as batch_exports
 from posthog.settings import EE_AVAILABLE
@@ -110,15 +110,23 @@ def register_grandfathered_environment_nested_viewset(
     return environment_nested, legacy_project_nested
 
 
-register_grandfathered_environment_nested_viewset(
-    r"plugin_configs", plugin.PluginConfigViewSet, "environment_plugin_configs", ["team_id"]
+environment_plugins_configs_router, legacy_project_plugins_configs_router = (
+    register_grandfathered_environment_nested_viewset(
+        r"plugin_configs", plugin.PluginConfigViewSet, "environment_plugin_configs", ["team_id"]
+    )
 )
-register_grandfathered_environment_nested_viewset(
+environment_plugins_configs_router.register(
     r"logs",
     plugin_log_entry.PluginLogEntryViewSet,
     "environment_plugin_config_logs",
     ["team_id", "plugin_config_id"],
 )
+legacy_project_plugins_configs_router.register(
+    r"logs",
+    plugin_log_entry.PluginLogEntryViewSet,
+    "project_plugin_config_logs",
+    ["team_id", "plugin_config_id"],
+)
 register_grandfathered_environment_nested_viewset(
     r"pipeline_transformation_configs",
     plugin.PipelineTransformationsConfigsViewSet,
@@ -549,6 +557,13 @@ def register_grandfathered_environment_nested_viewset(
     ["team_id"],
 )
 
+register_grandfathered_environment_nested_viewset(
+    r"metalytics",
+    metalytics.MetalyticsViewSet,
+    "environment_metalytics",
+    ["team_id"],
+)
+
 projects_router.register(
     r"insight_variables",
     insight_variable.InsightVariableViewSet,
diff --git a/posthog/api/activity_log.py b/posthog/api/activity_log.py
index 4730dde145ffb..d44c43073eb06 100644
--- a/posthog/api/activity_log.py
+++ b/posthog/api/activity_log.py
@@ -131,18 +131,30 @@ def important_changes(self, request: Request, *args: Any, **kwargs: Any) -> Resp
         with timer("gather_query_parts"):
             # first things this user created
             my_insights = list(
-                Insight.objects.filter(created_by=user, team_id=self.team.pk).values_list("id", flat=True)
+                Insight.objects.filter(created_by=user, team__project_id=self.team.project_id).values_list(
+                    "id", flat=True
+                )
             )
             my_feature_flags = list(
-                FeatureFlag.objects.filter(created_by=user, team_id=self.team.pk).values_list("id", flat=True)
+                FeatureFlag.objects.filter(created_by=user, team__project_id=self.team.project_id).values_list(
+                    "id", flat=True
+                )
             )
             my_notebooks = list(
-                Notebook.objects.filter(created_by=user, team_id=self.team.pk).values_list("short_id", flat=True)
+                Notebook.objects.filter(created_by=user, team__project_id=self.team.project_id).values_list(
+                    "short_id", flat=True
+                )
             )
             my_comments = list(
-                Comment.objects.filter(created_by=user, team_id=self.team.pk).values_list("id", flat=True)
+                Comment.objects.filter(created_by=user, team__project_id=self.team.project_id).values_list(
+                    "id", flat=True
+                )
+            )
+            my_cohorts = list(
+                Cohort.objects.filter(created_by=user, team__project_id=self.team.project_id).values_list(
+                    "id", flat=True
+                )
             )
-            my_cohorts = list(Cohort.objects.filter(created_by=user, team_id=self.team.pk).values_list("id", flat=True))
             my_hog_functions = list(
                 HogFunction.objects.filter(created_by=user, team_id=self.team.pk).values_list("id", flat=True)
             )
diff --git a/posthog/api/authentication.py b/posthog/api/authentication.py
index 81c572d06a665..96c3ede72332a 100644
--- a/posthog/api/authentication.py
+++ b/posthog/api/authentication.py
@@ -32,6 +32,7 @@
     get_remember_device_cookie,
     validate_remember_device_cookie,
 )
+from django_otp.plugins.otp_static.models import StaticDevice
 
 from posthog.api.email_verification import EmailVerifier, is_email_verification_disabled
 from posthog.email import is_email_available
@@ -247,16 +248,25 @@ def create(self, request: Request, *args: Any, **kwargs: Any) -> Any:
             )
 
         with transaction.atomic():
-            device = default_device(user)
-            is_allowed = device.verify_is_allowed()
-            if not is_allowed[0]:
-                raise serializers.ValidationError(detail="Too many attempts.", code="2fa_too_many_attempts")
-            if device.verify_token(request.data["token"]):
-                return self._token_is_valid(request, user, device)
-
-        # Failed attempt so increase throttle
-        device.throttle_increment()
-        raise serializers.ValidationError(detail="2FA token was not valid", code="2fa_invalid")
+            # First try TOTP device
+            totp_device = default_device(user)
+            if totp_device:
+                is_allowed = totp_device.verify_is_allowed()
+                if not is_allowed[0]:
+                    raise serializers.ValidationError(detail="Too many attempts.", code="2fa_too_many_attempts")
+                if totp_device.verify_token(request.data["token"]):
+                    return self._token_is_valid(request, user, totp_device)
+                totp_device.throttle_increment()
+
+            # Then try backup codes
+            # Backup codes are in place in case a user's device is lost or unavailable.
+            # They can be consumed in any order; each token will be removed from the
+            # database as soon as it is used.
+            static_device = StaticDevice.objects.filter(user=user).first()
+            if static_device and static_device.verify_token(request.data["token"]):
+                return self._token_is_valid(request, user, static_device)
+
+        raise serializers.ValidationError(detail="Invalid authentication code", code="2fa_invalid")
 
 
 class LoginPrecheckViewSet(NonCreatingViewSetMixin, viewsets.GenericViewSet):
diff --git a/posthog/api/cohort.py b/posthog/api/cohort.py
index 2d5d557f52b0b..3c83f7e1af415 100644
--- a/posthog/api/cohort.py
+++ b/posthog/api/cohort.py
@@ -14,6 +14,7 @@
 )
 from posthog.models.person.person import PersonDistinctId
 from posthog.models.property.property import Property, PropertyGroup
+from posthog.models.team.team import Team
 from posthog.queries.base import property_group_to_Q
 from posthog.metrics import LABEL_TEAM_ID
 from posthog.renderers import SafeJSONRenderer
@@ -22,8 +23,6 @@
 
 from django.conf import settings
 from django.db.models import QuerySet, Prefetch, prefetch_related_objects, OuterRef, Subquery
-from django.db.models.expressions import F
-from django.utils import timezone
 from rest_framework import serializers, viewsets, request, status
 from posthog.api.utils import action
 from rest_framework.exceptions import ValidationError
@@ -52,7 +51,7 @@
 from posthog.hogql.constants import CSV_EXPORT_LIMIT
 from posthog.event_usage import report_user_action
 from posthog.hogql.context import HogQLContext
-from posthog.models import Cohort, FeatureFlag, User, Person
+from posthog.models import Cohort, FeatureFlag, Person
 from posthog.models.async_deletion import AsyncDeletion, DeletionType
 from posthog.models.cohort.util import get_dependent_cohorts, print_cohort_hogql_query
 from posthog.models.cohort import CohortOrEmpty
@@ -139,14 +138,14 @@ def _handle_static(self, cohort: Cohort, context: dict, validated_data: dict) ->
         elif context.get("from_feature_flag_key"):
             insert_cohort_from_feature_flag.delay(cohort.pk, context["from_feature_flag_key"], self.context["team_id"])
         elif validated_data.get("query"):
-            insert_cohort_from_query.delay(cohort.pk)
+            insert_cohort_from_query.delay(cohort.pk, self.context["team_id"])
         else:
             filter_data = request.GET.dict()
             existing_cohort_id = context.get("from_cohort_id")
             if existing_cohort_id:
                 filter_data = {**filter_data, "from_cohort_id": existing_cohort_id}
             if filter_data:
-                insert_cohort_from_insight_filter.delay(cohort.pk, filter_data)
+                insert_cohort_from_insight_filter.delay(cohort.pk, filter_data, self.context["team_id"])
 
     def create(self, validated_data: dict, *args: Any, **kwargs: Any) -> Cohort:
         request = self.context["request"]
@@ -173,7 +172,7 @@ def _calculate_static_by_csv(self, file, cohort: Cohort) -> None:
         decoded_file = file.read().decode("utf-8").splitlines()
         reader = csv.reader(decoded_file)
         distinct_ids_and_emails = [row[0] for row in reader if len(row) > 0 and row]
-        calculate_cohort_from_list.delay(cohort.pk, distinct_ids_and_emails)
+        calculate_cohort_from_list.delay(cohort.pk, distinct_ids_and_emails, team_id=self.context["team_id"])
 
     def validate_query(self, query: Optional[dict]) -> Optional[dict]:
         if not query:
@@ -195,7 +194,7 @@ def validate_filters(self, request_filters: dict):
                 instance = cast(Cohort, self.instance)
                 cohort_id = instance.pk
                 flags: QuerySet[FeatureFlag] = FeatureFlag.objects.filter(
-                    team_id=self.context["team_id"], active=True, deleted=False
+                    team__project_id=self.context["project_id"], active=True, deleted=False
                 )
                 cohort_used_in_flags = len([flag for flag in flags if cohort_id in flag.get_cohort_ids()]) > 0
 
@@ -208,7 +207,7 @@ def validate_filters(self, request_filters: dict):
                             )
 
                     if prop.type == "cohort":
-                        nested_cohort = Cohort.objects.get(pk=prop.value, team_id=self.context["team_id"])
+                        nested_cohort = Cohort.objects.get(pk=prop.value, team__project_id=self.context["project_id"])
                         dependent_cohorts = get_dependent_cohorts(nested_cohort)
                         for dependent_cohort in [nested_cohort, *dependent_cohorts]:
                             if (
@@ -229,7 +228,6 @@ def validate_filters(self, request_filters: dict):
 
     def update(self, cohort: Cohort, validated_data: dict, *args: Any, **kwargs: Any) -> Cohort:  # type: ignore
         request = self.context["request"]
-        user = cast(User, request.user)
 
         cohort.name = validated_data.get("name", cohort.name)
         cohort.description = validated_data.get("description", cohort.description)
@@ -240,22 +238,29 @@ def update(self, cohort: Cohort, validated_data: dict, *args: Any, **kwargs: Any
 
         is_deletion_change = deleted_state is not None and cohort.deleted != deleted_state
         if is_deletion_change:
+            relevant_team_ids = Team.objects.filter(project_id=cohort.team.project_id).values_list("id", flat=True)
             cohort.deleted = deleted_state
             if deleted_state:
                 # De-attach from experiments
                 cohort.experiment_set.set([])
 
-                AsyncDeletion.objects.get_or_create(
-                    deletion_type=DeletionType.Cohort_full,
-                    team_id=cohort.team.pk,
-                    key=f"{cohort.pk}_{cohort.version}",
-                    created_by=user,
+                AsyncDeletion.objects.bulk_create(
+                    [
+                        AsyncDeletion(
+                            deletion_type=DeletionType.Cohort_full,
+                            team_id=team_id,
+                            # Only appending `team_id` if it's not the same as the cohort's `team_id``, so that
+                            # the migration to environments does not accidentally cause duplicate `AsyncDeletion`s
+                            key=f"{cohort.pk}_{cohort.version}{('_'+team_id) if team_id != cohort.team_id else ''}",
+                        )
+                        for team_id in relevant_team_ids
+                    ],
+                    ignore_conflicts=True,
                 )
             else:
                 AsyncDeletion.objects.filter(
                     deletion_type=DeletionType.Cohort_full,
-                    team_id=cohort.team.pk,
-                    key=f"{cohort.pk}_{cohort.version}",
+                    key__startswith=f"{cohort.pk}_{cohort.version}",  # We target this _prefix_, so all teams are covered
                 ).delete()
         elif not cohort.is_static:
             cohort.is_calculating = True
@@ -425,7 +430,7 @@ def activity(self, request: request.Request, **kwargs):
         page = int(request.query_params.get("page", "1"))
 
         item_id = kwargs["pk"]
-        if not Cohort.objects.filter(id=item_id, team_id=self.team_id).exists():
+        if not Cohort.objects.filter(id=item_id, team__project_id=self.project_id).exists():
             return Response("", status=status.HTTP_404_NOT_FOUND)
 
         activity_page = load_activity(
@@ -475,12 +480,12 @@ def perform_update(self, serializer):
 
 
 class LegacyCohortViewSet(CohortViewSet):
-    param_derived_from_user_current_team = "project_id"
+    param_derived_from_user_current_team = "team_id"
 
 
 def will_create_loops(cohort: Cohort) -> bool:
     # Loops can only be formed when trying to update a Cohort, not when creating one
-    team_id = cohort.team_id
+    project_id = cohort.team.project_id
 
     # We can model this as a directed graph, where each node is a Cohort and each edge is a reference to another Cohort
     # There's a loop only if there's a cycle in the directed graph. The "directed" bit is important.
@@ -501,7 +506,7 @@ def dfs_loop_helper(current_cohort: Cohort, seen_cohorts, cohorts_on_path):
                     return True
                 elif property.value not in seen_cohorts:
                     try:
-                        nested_cohort = Cohort.objects.get(pk=property.value, team_id=team_id)
+                        nested_cohort = Cohort.objects.get(pk=property.value, team__project_id=project_id)
                     except Cohort.DoesNotExist:
                         raise ValidationError("Invalid Cohort ID in filter")
 
@@ -514,23 +519,21 @@ def dfs_loop_helper(current_cohort: Cohort, seen_cohorts, cohorts_on_path):
     return dfs_loop_helper(cohort, set(), set())
 
 
-def insert_cohort_people_into_pg(cohort: Cohort):
+def insert_cohort_people_into_pg(cohort: Cohort, *, team_id: int):
     ids = sync_execute(
-        "SELECT person_id FROM {} where team_id = %(team_id)s AND cohort_id = %(cohort_id)s".format(
-            PERSON_STATIC_COHORT_TABLE
-        ),
-        {"cohort_id": cohort.pk, "team_id": cohort.team.pk},
+        f"SELECT person_id FROM {PERSON_STATIC_COHORT_TABLE} where team_id = %(team_id)s AND cohort_id = %(cohort_id)s",
+        {"cohort_id": cohort.pk, "team_id": team_id},
     )
-    cohort.insert_users_list_by_uuid(items=[str(id[0]) for id in ids])
+    cohort.insert_users_list_by_uuid(items=[str(id[0]) for id in ids], team_id=team_id)
 
 
-def insert_cohort_query_actors_into_ch(cohort: Cohort):
-    context = HogQLContext(enable_select_queries=True, team_id=cohort.team.pk)
-    query = print_cohort_hogql_query(cohort, context)
-    insert_actors_into_cohort_by_query(cohort, query, {}, context)
+def insert_cohort_query_actors_into_ch(cohort: Cohort, *, team: Team):
+    context = HogQLContext(enable_select_queries=True, team_id=team.id)
+    query = print_cohort_hogql_query(cohort, context, team=team)
+    insert_actors_into_cohort_by_query(cohort, query, {}, context, team_id=team.id)
 
 
-def insert_cohort_actors_into_ch(cohort: Cohort, filter_data: dict):
+def insert_cohort_actors_into_ch(cohort: Cohort, filter_data: dict, *, team_id: int):
     from_existing_cohort_id = filter_data.get("from_cohort_id")
     context: HogQLContext
 
@@ -543,7 +546,7 @@ def insert_cohort_actors_into_ch(cohort: Cohort, filter_data: dict):
             ORDER BY person_id
         """
         params = {
-            "team_id": cohort.team.pk,
+            "team_id": team_id,
             "from_cohort_id": existing_cohort.pk,
             "version": existing_cohort.version,
         }
@@ -590,49 +593,37 @@ def insert_cohort_actors_into_ch(cohort: Cohort, filter_data: dict):
         else:
             query, params = query_builder.actor_query(limit_actors=False)
 
-    insert_actors_into_cohort_by_query(cohort, query, params, context)
-
-
-def insert_actors_into_cohort_by_query(cohort: Cohort, query: str, params: dict[str, Any], context: HogQLContext):
-    try:
-        sync_execute(
-            INSERT_COHORT_ALL_PEOPLE_THROUGH_PERSON_ID.format(cohort_table=PERSON_STATIC_COHORT_TABLE, query=query),
-            {
-                "cohort_id": cohort.pk,
-                "_timestamp": datetime.now(),
-                "team_id": cohort.team.pk,
-                **context.values,
-                **params,
-            },
-        )
-
-        cohort.is_calculating = False
-        cohort.last_calculation = timezone.now()
-        cohort.errors_calculating = 0
-        cohort.last_error_at = None
-        cohort.save(update_fields=["errors_calculating", "last_calculation", "is_calculating", "last_error_at"])
-    except Exception as err:
-        if settings.DEBUG:
-            raise
-        cohort.is_calculating = False
-        cohort.errors_calculating = F("errors_calculating") + 1
-        cohort.last_error_at = timezone.now()
-        cohort.save(update_fields=["errors_calculating", "is_calculating", "last_error_at"])
-        capture_exception(err)
+    insert_actors_into_cohort_by_query(cohort, query, params, context, team_id=team_id)
+
+
+def insert_actors_into_cohort_by_query(
+    cohort: Cohort, query: str, params: dict[str, Any], context: HogQLContext, *, team_id: int
+):
+    sync_execute(
+        INSERT_COHORT_ALL_PEOPLE_THROUGH_PERSON_ID.format(cohort_table=PERSON_STATIC_COHORT_TABLE, query=query),
+        {
+            "cohort_id": cohort.pk,
+            "_timestamp": datetime.now(),
+            "team_id": team_id,
+            **context.values,
+            **params,
+        },
+    )
 
 
 def get_cohort_actors_for_feature_flag(cohort_id: int, flag: str, team_id: int, batchsize: int = 1_000):
     # :TODO: Find a way to incorporate this into the same code path as feature flag evaluation
+    project_id = Team.objects.only("project_id").get(pk=team_id).project_id
     try:
-        feature_flag = FeatureFlag.objects.get(team_id=team_id, key=flag)
+        feature_flag = FeatureFlag.objects.get(team__project_id=project_id, key=flag)
     except FeatureFlag.DoesNotExist:
         return []
 
     if not feature_flag.active or feature_flag.deleted or feature_flag.aggregation_group_type_index is not None:
         return []
 
-    cohort = Cohort.objects.get(pk=cohort_id, team_id=team_id)
-    matcher_cache = FlagsMatcherCache(team_id)
+    cohort = Cohort.objects.get(pk=cohort_id, team__project_id=project_id)
+    matcher_cache = FlagsMatcherCache(team_id=team_id)
     uuids_to_add_to_cohort = []
     cohorts_cache: dict[int, CohortOrEmpty] = {}
 
@@ -640,7 +631,9 @@ def get_cohort_actors_for_feature_flag(cohort_id: int, flag: str, team_id: int,
         # TODO: Consider disabling flags with cohorts for creating static cohorts
         # because this is currently a lot more inefficient for flag matching,
         # as we're required to go to the database for each person.
-        cohorts_cache = {cohort.pk: cohort for cohort in Cohort.objects.filter(team_id=team_id, deleted=False)}
+        cohorts_cache = {
+            cohort.pk: cohort for cohort in Cohort.objects.filter(team__project_id=project_id, deleted=False)
+        }
 
     default_person_properties = {}
     for condition in feature_flag.conditions:
@@ -727,7 +720,7 @@ def get_cohort_actors_for_feature_flag(cohort_id: int, flag: str, team_id: int,
 
                     if len(uuids_to_add_to_cohort) >= batchsize:
                         cohort.insert_users_list_by_uuid(
-                            uuids_to_add_to_cohort, insert_in_clickhouse=True, batchsize=batchsize
+                            uuids_to_add_to_cohort, insert_in_clickhouse=True, batchsize=batchsize, team_id=team_id
                         )
                         uuids_to_add_to_cohort = []
 
@@ -735,7 +728,9 @@ def get_cohort_actors_for_feature_flag(cohort_id: int, flag: str, team_id: int,
             batch_of_persons = queryset[start : start + batchsize]
 
         if len(uuids_to_add_to_cohort) > 0:
-            cohort.insert_users_list_by_uuid(uuids_to_add_to_cohort, insert_in_clickhouse=True, batchsize=batchsize)
+            cohort.insert_users_list_by_uuid(
+                uuids_to_add_to_cohort, insert_in_clickhouse=True, batchsize=batchsize, team_id=team_id
+            )
 
     except Exception as err:
         if settings.DEBUG or settings.TEST:
diff --git a/posthog/api/dashboards/dashboard.py b/posthog/api/dashboards/dashboard.py
index 8fbbb98b58404..393df01a2d554 100644
--- a/posthog/api/dashboards/dashboard.py
+++ b/posthog/api/dashboards/dashboard.py
@@ -214,7 +214,9 @@ def create(self, validated_data: dict, *args: Any, **kwargs: Any) -> Dashboard:
 
         elif use_dashboard:
             try:
-                existing_dashboard = Dashboard.objects.get(id=use_dashboard, team_id=team_id)
+                existing_dashboard = Dashboard.objects.get(
+                    id=use_dashboard, team__project_id=self.context["get_team"]().project_id
+                )
                 existing_tiles = (
                     DashboardTile.objects.filter(dashboard=existing_dashboard)
                     .exclude(deleted=True)
diff --git a/posthog/api/decide.py b/posthog/api/decide.py
index c636ac58fcd9e..98b331de0472d 100644
--- a/posthog/api/decide.py
+++ b/posthog/api/decide.py
@@ -1,5 +1,5 @@
 from random import random
-from typing import Union, cast
+from typing import Any, Union
 
 import structlog
 from django.conf import settings
@@ -14,8 +14,7 @@
 from posthog.api.utils import (
     get_project_id,
     get_token,
-    hostname_in_allowed_url_list,
-    parse_domain,
+    on_permitted_recording_domain,
 )
 from posthog.database_healthcheck import DATABASE_FOR_FLAG_MATCHING
 from posthog.exceptions import (
@@ -30,8 +29,9 @@
 from posthog.models.feature_flag import get_all_feature_flags
 from posthog.models.feature_flag.flag_analytics import increment_request_count
 from posthog.models.filters.mixins.utils import process_bool
+from posthog.models.remote_config import RemoteConfig
 from posthog.models.utils import execute_with_timeout
-from posthog.plugins.site import get_decide_site_apps, get_decide_site_functions
+from posthog.plugins.site import get_decide_site_apps
 from posthog.utils import (
     get_ip_address,
     label_for_team_id_to_track,
@@ -46,30 +46,26 @@
 )
 
 
-def on_permitted_recording_domain(team: Team, request: HttpRequest) -> bool:
-    origin = parse_domain(request.headers.get("Origin"))
-    referer = parse_domain(request.headers.get("Referer"))
-    user_agent = request.META.get("HTTP_USER_AGENT")
-
-    is_authorized_web_client: bool = hostname_in_allowed_url_list(
-        team.recording_domains, origin
-    ) or hostname_in_allowed_url_list(team.recording_domains, referer)
-    # TODO this is a short term fix for beta testers
-    # TODO we will match on the app identifier in the origin instead and allow users to auth those
-    is_authorized_mobile_client: bool = user_agent is not None and any(
-        keyword in user_agent
-        for keyword in ["posthog-android", "posthog-ios", "posthog-react-native", "posthog-flutter"]
+def get_base_config(token: str, team: Team, request: HttpRequest, skip_db: bool = False) -> dict:
+    # Check for query param "use_remote_config"
+    use_remote_config = request.GET.get("use_remote_config") == "true" or token in (
+        settings.DECIDE_TOKENS_FOR_REMOTE_CONFIG or []
     )
 
-    return is_authorized_web_client or is_authorized_mobile_client
+    if use_remote_config:
+        response = RemoteConfig.get_config_via_token(token, request=request)
 
+        # Add in a bunch of backwards compatibility stuff
+        response["isAuthenticated"] = False
+        response["toolbarParams"] = {}
+        response["config"] = {"enable_collect_everything": True}
+        response["surveys"] = True if len(response["surveys"]) > 0 else False
 
-@csrf_exempt
-@timed("posthog_cloud_decide_endpoint")
-def get_decide(request: HttpRequest):
-    # handle cors request
-    if request.method == "OPTIONS":
-        return cors_response(request, JsonResponse({"status": 1}))
+        # Remove some stuff that is specific to the new RemoteConfig
+        del response["hasFeatureFlags"]
+        del response["token"]
+
+        return response
 
     response = {
         "config": {"enable_collect_everything": True},
@@ -81,271 +77,287 @@ def get_decide(request: HttpRequest):
         "sessionRecording": False,
     }
 
-    if request.method == "POST":
-        try:
-            data = load_data_from_request(request)
-            api_version_string = request.GET.get("v")
-            # NOTE: This does not support semantic versioning e.g. 2.1.0
-            api_version = int(api_version_string) if api_version_string else 1
-        except ValueError:
-            # default value added because of bug in posthog-js 1.19.0
-            # see https://sentry.io/organizations/posthog2/issues/2738865125/?project=1899813
-            # as a tombstone if the below statsd counter hasn't seen errors for N days
-            # then it is likely that no clients are running posthog-js 1.19.0
-            # and this defaulting could be removed
-            statsd.incr(
-                f"posthog_cloud_decide_defaulted_api_version_on_value_error",
-                tags={"endpoint": "decide", "api_version_string": api_version_string},
-            )
-            api_version = 2
-        except UnspecifiedCompressionFallbackParsingError as error:
-            # Notably don't capture this exception as it's not caused by buggy behavior,
-            # it's just a fallback for when we can't parse the request due to a missing header
-            # that we attempted to kludge by manually setting the compression type to gzip
-            # If this kludge fails, though all we need to do is return a 400 and move on
-            return cors_response(
-                request,
-                generate_exception_response("decide", f"Malformed request data: {error}", code="malformed_data"),
-            )
-        except RequestParsingError as error:
-            capture_exception(error)  # We still capture this on Sentry to identify actual potential bugs
-            return cors_response(
-                request,
-                generate_exception_response("decide", f"Malformed request data: {error}", code="malformed_data"),
-            )
+    response["captureDeadClicks"] = True if team.capture_dead_clicks else False
+
+    capture_network_timing = True if team.capture_performance_opt_in else False
+    capture_web_vitals = True if team.autocapture_web_vitals_opt_in else False
+    autocapture_web_vitals_allowed_metrics = None
+    if capture_web_vitals:
+        autocapture_web_vitals_allowed_metrics = team.autocapture_web_vitals_allowed_metrics
+    response["capturePerformance"] = (
+        {
+            "network_timing": capture_network_timing,
+            "web_vitals": capture_web_vitals,
+            "web_vitals_allowed_metrics": autocapture_web_vitals_allowed_metrics,
+        }
+        if capture_network_timing or capture_web_vitals
+        else False
+    )
 
-        token = get_token(data, request)
-        team = Team.objects.get_team_from_cache_or_token(token)
-        if team is None and token:
-            project_id = get_project_id(data, request)
+    response["autocapture_opt_out"] = True if team.autocapture_opt_out else False
+    response["autocaptureExceptions"] = (
+        {
+            "endpoint": "/e/",
+        }
+        if team.autocapture_exceptions_opt_in
+        else False
+    )
 
-            if not project_id:
-                return cors_response(
-                    request,
-                    generate_exception_response(
-                        "decide",
-                        "Project API key invalid. You can find your project API key in PostHog project settings.",
-                        code="invalid_api_key",
-                        type="authentication_error",
-                        status_code=status.HTTP_401_UNAUTHORIZED,
-                    ),
-                )
+    # this not settings.DEBUG check is a lazy workaround because
+    # NEW_ANALYTICS_CAPTURE_ENDPOINT doesn't currently work in DEBUG mode
+    if not settings.DEBUG and str(team.id) not in (settings.NEW_ANALYTICS_CAPTURE_EXCLUDED_TEAM_IDS or []):
+        response["analytics"] = {"endpoint": settings.NEW_ANALYTICS_CAPTURE_ENDPOINT}
 
-            user = User.objects.get_from_personal_api_key(token)
-            if user is None:
-                return cors_response(
-                    request,
-                    generate_exception_response(
-                        "decide",
-                        "Invalid Personal API key.",
-                        code="invalid_personal_key",
-                        type="authentication_error",
-                        status_code=status.HTTP_401_UNAUTHORIZED,
-                    ),
-                )
-            team = user.teams.get(id=project_id)
+    if str(team.id) not in (settings.ELEMENT_CHAIN_AS_STRING_EXCLUDED_TEAMS or []):
+        response["elementsChainAsString"] = True
 
-        if team:
-            if team.id in settings.DECIDE_SHORT_CIRCUITED_TEAM_IDS:
-                return cors_response(
-                    request,
-                    generate_exception_response(
-                        "decide",
-                        f"Team with ID {team.id} cannot access the /decide endpoint."
-                        f"Please contact us at hey@posthog.com",
-                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                    ),
-                )
+    response["sessionRecording"] = _session_recording_config_response(request, team)
 
-            token = cast(str, token)  # we know it's not None if we found a team
-            structlog.contextvars.bind_contextvars(team_id=team.id)
-
-            disable_flags = process_bool(data.get("disable_flags")) is True
-            feature_flags = None
-            errors = False
-            if not disable_flags:
-                distinct_id = data.get("distinct_id")
-                if distinct_id is None:
-                    return cors_response(
-                        request,
-                        generate_exception_response(
-                            "decide",
-                            "Decide requires a distinct_id.",
-                            code="missing_distinct_id",
-                            type="validation_error",
-                            status_code=status.HTTP_400_BAD_REQUEST,
-                        ),
-                    )
-                else:
-                    distinct_id = str(distinct_id)
+    if settings.DECIDE_SESSION_REPLAY_QUOTA_CHECK:
+        from ee.billing.quota_limiting import (
+            QuotaLimitingCaches,
+            QuotaResource,
+            list_limited_team_attributes,
+        )
 
-                property_overrides = {}
-                geoip_enabled = process_bool(data.get("geoip_disable")) is False
+        limited_tokens_recordings = list_limited_team_attributes(
+            QuotaResource.RECORDINGS, QuotaLimitingCaches.QUOTA_LIMITER_CACHE_KEY
+        )
 
-                if geoip_enabled:
-                    property_overrides = get_geoip_properties(get_ip_address(request))
+        if token in limited_tokens_recordings:
+            response["quotaLimited"] = ["recordings"]
+            response["sessionRecording"] = False
 
-                all_property_overrides: dict[str, Union[str, int]] = {
-                    **property_overrides,
-                    **(data.get("person_properties") or {}),
-                }
+    response["surveys"] = True if team.surveys_opt_in else False
+    response["heatmaps"] = True if team.heatmaps_opt_in else False
+    response["defaultIdentifiedOnly"] = True  # Support old SDK versions with setting that is now the default
 
-                feature_flags, _, feature_flag_payloads, errors = get_all_feature_flags(
-                    team.pk,
-                    distinct_id,
-                    data.get("groups") or {},
-                    hash_key_override=data.get("$anon_distinct_id"),
-                    property_value_overrides=all_property_overrides,
-                    group_property_value_overrides=(data.get("group_properties") or {}),
-                )
+    site_apps = []
+    # errors mean the database is unavailable, bail in this case
+    if team.inject_web_apps and not skip_db:
+        try:
+            with execute_with_timeout(200, DATABASE_FOR_FLAG_MATCHING):
+                site_apps = get_decide_site_apps(team, using_database=DATABASE_FOR_FLAG_MATCHING)
+        except Exception:
+            pass
 
-                active_flags = {key: value for key, value in feature_flags.items() if value}
+    response["siteApps"] = site_apps
+
+    return response
 
-                if api_version == 2:
-                    response["featureFlags"] = active_flags
-                elif api_version >= 3:
-                    # v3 returns all flags, not just active ones, as well as if there was an error computing all flags
-                    response["featureFlags"] = feature_flags
-                    response["errorsWhileComputingFlags"] = errors
-                    response["featureFlagPayloads"] = feature_flag_payloads
-                else:
-                    # default v1
-                    response["featureFlags"] = list(active_flags.keys())
-
-                # metrics for feature flags
-                team_id_label = label_for_team_id_to_track(team.pk)
-                FLAG_EVALUATION_COUNTER.labels(
-                    team_id=team_id_label,
-                    errors_computing=errors,
-                    has_hash_key_override=bool(data.get("$anon_distinct_id")),
-                ).inc()
-            else:
-                response["featureFlags"] = {}
 
-            response["captureDeadClicks"] = True if team.capture_dead_clicks else False
+@csrf_exempt
+@timed("posthog_cloud_decide_endpoint")
+def get_decide(request: HttpRequest):
+    # handle cors request
+    if request.method == "OPTIONS":
+        return cors_response(request, JsonResponse({"status": 1}))
 
-            capture_network_timing = True if team.capture_performance_opt_in else False
-            capture_web_vitals = True if team.autocapture_web_vitals_opt_in else False
-            autocapture_web_vitals_allowed_metrics = None
-            if capture_web_vitals:
-                autocapture_web_vitals_allowed_metrics = team.autocapture_web_vitals_allowed_metrics
-            response["capturePerformance"] = (
+    if request.method != "POST":
+        statsd.incr(f"posthog_cloud_raw_endpoint_success", tags={"endpoint": "decide"})
+        return cors_response(
+            request,
+            JsonResponse(
                 {
-                    "network_timing": capture_network_timing,
-                    "web_vitals": capture_web_vitals,
-                    "web_vitals_allowed_metrics": autocapture_web_vitals_allowed_metrics,
+                    "config": {"enable_collect_everything": True},
+                    "toolbarParams": {},
+                    "isAuthenticated": False,
+                    # gzip and gzip-js are aliases for the same compression algorithm
+                    "supportedCompression": ["gzip", "gzip-js"],
+                    "featureFlags": [],
+                    "sessionRecording": False,
                 }
-                if capture_network_timing or capture_web_vitals
-                else False
+            ),
+        )
+
+    try:
+        data = load_data_from_request(request)
+        api_version_string = request.GET.get("v")
+        # NOTE: This does not support semantic versioning e.g. 2.1.0
+        api_version = int(api_version_string) if api_version_string else 1
+    except ValueError:
+        # default value added because of bug in posthog-js 1.19.0
+        # see https://sentry.io/organizations/posthog2/issues/2738865125/?project=1899813
+        # as a tombstone if the below statsd counter hasn't seen errors for N days
+        # then it is likely that no clients are running posthog-js 1.19.0
+        # and this defaulting could be removed
+        statsd.incr(
+            f"posthog_cloud_decide_defaulted_api_version_on_value_error",
+            tags={"endpoint": "decide", "api_version_string": api_version_string},
+        )
+        api_version = 2
+    except UnspecifiedCompressionFallbackParsingError as error:
+        # Notably don't capture this exception as it's not caused by buggy behavior,
+        # it's just a fallback for when we can't parse the request due to a missing header
+        # that we attempted to kludge by manually setting the compression type to gzip
+        # If this kludge fails, though all we need to do is return a 400 and move on
+        return cors_response(
+            request,
+            generate_exception_response("decide", f"Malformed request data: {error}", code="malformed_data"),
+        )
+    except RequestParsingError as error:
+        capture_exception(error)  # We still capture this on Sentry to identify actual potential bugs
+        return cors_response(
+            request,
+            generate_exception_response("decide", f"Malformed request data: {error}", code="malformed_data"),
+        )
+
+    token = get_token(data, request)
+    team = Team.objects.get_team_from_cache_or_token(token)
+    if team is None and token:
+        project_id = get_project_id(data, request)
+
+        if not project_id:
+            return cors_response(
+                request,
+                generate_exception_response(
+                    "decide",
+                    "Project API key invalid. You can find your project API key in PostHog project settings.",
+                    code="invalid_api_key",
+                    type="authentication_error",
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                ),
             )
 
-            response["autocapture_opt_out"] = True if team.autocapture_opt_out else False
-            response["autocaptureExceptions"] = (
-                {
-                    "endpoint": "/e/",
-                }
-                if team.autocapture_exceptions_opt_in
-                else False
+        user = User.objects.get_from_personal_api_key(token)
+        if user is None:
+            return cors_response(
+                request,
+                generate_exception_response(
+                    "decide",
+                    "Invalid Personal API key.",
+                    code="invalid_personal_key",
+                    type="authentication_error",
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                ),
             )
+        team = user.teams.get(id=project_id)
 
-            if str(team.id) not in settings.NEW_ANALYTICS_CAPTURE_EXCLUDED_TEAM_IDS:
-                if (
-                    "*" in settings.NEW_ANALYTICS_CAPTURE_TEAM_IDS
-                    or str(team.id) in settings.NEW_ANALYTICS_CAPTURE_TEAM_IDS
-                ):
-                    if random() < settings.NEW_ANALYTICS_CAPTURE_SAMPLING_RATE:
-                        response["analytics"] = {"endpoint": settings.NEW_ANALYTICS_CAPTURE_ENDPOINT}
-
-            if (
-                "*" in settings.NEW_CAPTURE_ENDPOINTS_INCLUDED_TEAM_IDS
-                or str(team.id) in settings.NEW_CAPTURE_ENDPOINTS_INCLUDED_TEAM_IDS
-            ):
-                if random() < settings.NEW_CAPTURE_ENDPOINTS_SAMPLING_RATE:
-                    response["__preview_ingestion_endpoints"] = True
+    if team:
+        if team.id in settings.DECIDE_SHORT_CIRCUITED_TEAM_IDS:
+            return cors_response(
+                request,
+                generate_exception_response(
+                    "decide",
+                    f"Team with ID {team.id} cannot access the /decide endpoint."
+                    f"Please contact us at hey@posthog.com",
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                ),
+            )
 
-            if (
-                settings.ELEMENT_CHAIN_AS_STRING_EXCLUDED_TEAMS
-                and str(team.id) not in settings.ELEMENT_CHAIN_AS_STRING_EXCLUDED_TEAMS
-            ):
-                response["elementsChainAsString"] = True
+        token = team.api_token
 
-            response["sessionRecording"] = _session_recording_config_response(request, team, token)
+        structlog.contextvars.bind_contextvars(team_id=team.id)
 
-            if settings.DECIDE_SESSION_REPLAY_QUOTA_CHECK:
-                from ee.billing.quota_limiting import (
-                    QuotaLimitingCaches,
-                    QuotaResource,
-                    list_limited_team_attributes,
-                )
+        disable_flags = process_bool(data.get("disable_flags")) is True
+        feature_flags = None
+        errors = False
+        flags_response: dict[str, Any] = {}
 
-                limited_tokens_recordings = list_limited_team_attributes(
-                    QuotaResource.RECORDINGS, QuotaLimitingCaches.QUOTA_LIMITER_CACHE_KEY
+        if not disable_flags:
+            distinct_id = data.get("distinct_id")
+            if distinct_id is None:
+                return cors_response(
+                    request,
+                    generate_exception_response(
+                        "decide",
+                        "Decide requires a distinct_id.",
+                        code="missing_distinct_id",
+                        type="validation_error",
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                    ),
                 )
+            else:
+                distinct_id = str(distinct_id)
 
-                if token in limited_tokens_recordings:
-                    response["quotaLimited"] = ["recordings"]
-                    response["sessionRecording"] = False
-
-            response["surveys"] = True if team.surveys_opt_in else False
-            response["heatmaps"] = True if team.heatmaps_opt_in else False
-            try:
-                default_identified_only = team.pk >= int(settings.DEFAULT_IDENTIFIED_ONLY_TEAM_ID_MIN)
-            except Exception:
-                default_identified_only = False
-            response["defaultIdentifiedOnly"] = bool(default_identified_only)
-
-            site_apps = []
-            # errors mean the database is unavailable, bail in this case
-            if team.inject_web_apps and not errors:
-                try:
-                    with execute_with_timeout(200, DATABASE_FOR_FLAG_MATCHING):
-                        site_apps = get_decide_site_apps(team, using_database=DATABASE_FOR_FLAG_MATCHING)
-                    with execute_with_timeout(200, DATABASE_FOR_FLAG_MATCHING):
-                        site_apps += get_decide_site_functions(team, using_database=DATABASE_FOR_FLAG_MATCHING)
-                except Exception:
-                    pass
-
-            response["siteApps"] = site_apps
-
-            # NOTE: Whenever you add something to decide response, update this test:
-            # `test_decide_doesnt_error_out_when_database_is_down`
-            # which ensures that decide doesn't error out when the database is down
-
-            if feature_flags:
-                # Billing analytics for decide requests with feature flags
-                # Don't count if all requests are for survey targeting flags only.
-                if not all(flag.startswith(SURVEY_TARGETING_FLAG_PREFIX) for flag in feature_flags.keys()):
-                    # Sample no. of decide requests with feature flags
-                    if settings.DECIDE_BILLING_SAMPLING_RATE and random() < settings.DECIDE_BILLING_SAMPLING_RATE:
-                        count = int(1 / settings.DECIDE_BILLING_SAMPLING_RATE)
-                        increment_request_count(team.pk, count)
+            property_overrides = {}
+            geoip_enabled = process_bool(data.get("geoip_disable")) is False
 
-        else:
-            # no auth provided
-            return cors_response(
-                request,
-                generate_exception_response(
-                    "decide",
-                    "No project API key provided. You can find your project API key in PostHog project settings.",
-                    code="no_api_key",
-                    type="authentication_error",
-                    status_code=status.HTTP_401_UNAUTHORIZED,
-                ),
+            if geoip_enabled:
+                property_overrides = get_geoip_properties(get_ip_address(request))
+
+            all_property_overrides: dict[str, Union[str, int]] = {
+                **property_overrides,
+                **(data.get("person_properties") or {}),
+            }
+
+            feature_flags, _, feature_flag_payloads, errors = get_all_feature_flags(
+                team.pk,
+                distinct_id,
+                data.get("groups") or {},
+                hash_key_override=data.get("$anon_distinct_id"),
+                property_value_overrides=all_property_overrides,
+                group_property_value_overrides=(data.get("group_properties") or {}),
             )
 
+            active_flags = {key: value for key, value in feature_flags.items() if value}
+
+            if api_version == 2:
+                flags_response["featureFlags"] = active_flags
+            elif api_version >= 3:
+                # v3 returns all flags, not just active ones, as well as if there was an error computing all flags
+                flags_response["featureFlags"] = feature_flags
+                flags_response["errorsWhileComputingFlags"] = errors
+                flags_response["featureFlagPayloads"] = feature_flag_payloads
+            else:
+                # default v1
+                flags_response["featureFlags"] = list(active_flags.keys())
+
+            # metrics for feature flags
+            team_id_label = label_for_team_id_to_track(team.pk)
+            FLAG_EVALUATION_COUNTER.labels(
+                team_id=team_id_label,
+                errors_computing=errors,
+                has_hash_key_override=bool(data.get("$anon_distinct_id")),
+            ).inc()
+        else:
+            flags_response["featureFlags"] = {}
+
+        # NOTE: Changed code - everything not feature flags goes in here
+        response = get_base_config(token, team, request, skip_db=errors)
+        response.update(flags_response)
+
+        # NOTE: Whenever you add something to decide response, update this test:
+        # `test_decide_doesnt_error_out_when_database_is_down`
+        # which ensures that decide doesn't error out when the database is down
+
+        if feature_flags:
+            # Billing analytics for decide requests with feature flags
+            # Don't count if all requests are for survey targeting flags only.
+            if not all(flag.startswith(SURVEY_TARGETING_FLAG_PREFIX) for flag in feature_flags.keys()):
+                # Sample no. of decide requests with feature flags
+                if settings.DECIDE_BILLING_SAMPLING_RATE and random() < settings.DECIDE_BILLING_SAMPLING_RATE:
+                    count = int(1 / settings.DECIDE_BILLING_SAMPLING_RATE)
+                    increment_request_count(team.pk, count)
+
+    else:
+        # no auth provided
+        return cors_response(
+            request,
+            generate_exception_response(
+                "decide",
+                "No project API key provided. You can find your project API key in PostHog project settings.",
+                code="no_api_key",
+                type="authentication_error",
+                status_code=status.HTTP_401_UNAUTHORIZED,
+            ),
+        )
+
     statsd.incr(f"posthog_cloud_raw_endpoint_success", tags={"endpoint": "decide"})
     return cors_response(request, JsonResponse(response))
 
 
-def _session_recording_config_response(request: HttpRequest, team: Team, token: str) -> bool | dict:
+def _session_recording_domain_not_allowed(team: Team, request: HttpRequest) -> bool:
+    return team.recording_domains and not on_permitted_recording_domain(team.recording_domains, request)
+
+
+def _session_recording_config_response(request: HttpRequest, team: Team) -> bool | dict:
     session_recording_config_response: bool | dict = False
 
     try:
-        if team.session_recording_opt_in and (
-            on_permitted_recording_domain(team, request) or not team.recording_domains
-        ):
+        if team.session_recording_opt_in and not _session_recording_domain_not_allowed(team, request):
             capture_console_logs = True if team.capture_console_log_opt_in else False
-            sample_rate = team.session_recording_sample_rate or None
+            sample_rate = str(team.session_recording_sample_rate) if team.session_recording_sample_rate else None
             if sample_rate == "1.00":
                 sample_rate = None
 
diff --git a/posthog/api/early_access_feature.py b/posthog/api/early_access_feature.py
index 004725393b4db..a7cc6cd42558e 100644
--- a/posthog/api/early_access_feature.py
+++ b/posthog/api/early_access_feature.py
@@ -270,9 +270,9 @@ def early_access_features(request: Request):
         )
 
     early_access_features = MinimalEarlyAccessFeatureSerializer(
-        EarlyAccessFeature.objects.filter(team_id=team.id, stage=EarlyAccessFeature.Stage.BETA).select_related(
-            "feature_flag"
-        ),
+        EarlyAccessFeature.objects.filter(
+            team__project_id=team.project_id, stage=EarlyAccessFeature.Stage.BETA
+        ).select_related("feature_flag"),
         many=True,
     ).data
 
diff --git a/posthog/api/email_verification.py b/posthog/api/email_verification.py
index 83c12d1dfe1e9..796e4c616d97f 100644
--- a/posthog/api/email_verification.py
+++ b/posthog/api/email_verification.py
@@ -25,7 +25,9 @@ def _make_hash_value(self, user: AbstractBaseUser, timestamp):
         # Due to type differences between the user model and the token generator, we need to
         # re-fetch the user from the database to get the correct type.
         usable_user: User = User.objects.get(pk=user.pk)
-        return f"{usable_user.pk}{usable_user.email}{usable_user.pending_email}{timestamp}"
+        login_timestamp = "" if user.last_login is None else user.last_login.replace(microsecond=0, tzinfo=None)
+
+        return f"{usable_user.pk}{usable_user.email}{usable_user.pending_email}{login_timestamp}{timestamp}"
 
 
 email_verification_token_generator = EmailVerificationTokenGenerator()
diff --git a/posthog/api/error_tracking.py b/posthog/api/error_tracking.py
index 9cdfd10f09122..7f554880ff2cf 100644
--- a/posthog/api/error_tracking.py
+++ b/posthog/api/error_tracking.py
@@ -10,8 +10,8 @@
 
 from posthog.api.forbid_destroy_model import ForbidDestroyModel
 from posthog.api.routing import TeamAndOrgViewSetMixin
-from posthog.models import ErrorTrackingSymbolSet
-from posthog.models.error_tracking import ErrorTrackingStackFrame
+from posthog.api.utils import action
+from posthog.models.error_tracking import ErrorTrackingIssue, ErrorTrackingSymbolSet, ErrorTrackingStackFrame
 from posthog.models.utils import uuid7
 from posthog.storage import object_storage
 
@@ -28,29 +28,26 @@ class ObjectStorageUnavailable(Exception):
     pass
 
 
-# class ErrorTrackingGroupSerializer(serializers.ModelSerializer):
-#     class Meta:
-#         model = ErrorTrackingGroup
-#         fields = ["assignee", "status"]
+class ErrorTrackingIssueSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ErrorTrackingIssue
+        fields = ["assignee", "status"]
 
 
-# class ErrorTrackingGroupViewSet(TeamAndOrgViewSetMixin, ForbidDestroyModel, viewsets.ModelViewSet):
-#     scope_object = "INTERNAL"
-#     queryset = ErrorTrackingGroup.objects.all()
-#     serializer_class = ErrorTrackingGroupSerializer
+class ErrorTrackingGroupViewSet(TeamAndOrgViewSetMixin, ForbidDestroyModel, viewsets.ModelViewSet):
+    scope_object = "INTERNAL"
+    queryset = ErrorTrackingIssue.objects.all()
+    serializer_class = ErrorTrackingIssueSerializer
 
-#     def safely_get_object(self, queryset) -> QuerySet:
-#         stringified_fingerprint = self.kwargs["pk"]
-#         fingerprint = json.loads(urlsafe_base64_decode(stringified_fingerprint))
-#         group, _ = queryset.get_or_create(fingerprint=fingerprint, team=self.team)
-#         return group
+    def safely_get_queryset(self, queryset):
+        return queryset.filter(team_id=self.team.id)
 
-#     @action(methods=["POST"], detail=True)
-#     def merge(self, request, **kwargs):
-#         group: ErrorTrackingGroup = self.get_object()
-#         merging_fingerprints: list[list[str]] = request.data.get("merging_fingerprints", [])
-#         group.merge(merging_fingerprints)
-#         return Response({"success": True})
+    @action(methods=["POST"], detail=True)
+    def merge(self, request, **kwargs):
+        issue: ErrorTrackingIssue = self.get_object()
+        ids: list[str] = request.data.get("ids", [])
+        issue.merge(issue_ids=ids)
+        return Response({"success": True})
 
 
 class ErrorTrackingStackFrameSerializer(serializers.ModelSerializer):
diff --git a/posthog/api/feature_flag.py b/posthog/api/feature_flag.py
index 06727c74bcf53..f20c1a4a6105a 100644
--- a/posthog/api/feature_flag.py
+++ b/posthog/api/feature_flag.py
@@ -56,6 +56,7 @@
 from posthog.models.feedback.survey import Survey
 from posthog.models.group_type_mapping import GroupTypeMapping
 from posthog.models.property import Property
+from posthog.models.feature_flag.flag_status import FeatureFlagStatusChecker, FeatureFlagStatus
 from posthog.queries.base import (
     determine_parsed_date_for_property_matching,
 )
@@ -256,7 +257,9 @@ def properties_all_match(predicate):
 
                 if prop.type == "cohort":
                     try:
-                        initial_cohort: Cohort = Cohort.objects.get(pk=prop.value, team_id=self.context["team_id"])
+                        initial_cohort: Cohort = Cohort.objects.get(
+                            pk=prop.value, team__project_id=self.context["project_id"]
+                        )
                         dependent_cohorts = get_dependent_cohorts(initial_cohort)
                         for cohort in [initial_cohort, *dependent_cohorts]:
                             if [prop for prop in cohort.properties.flat if prop.type == "behavioral"]:
@@ -352,7 +355,7 @@ def create(self, validated_data: dict, *args: Any, **kwargs: Any) -> FeatureFlag
 
         try:
             FeatureFlag.objects.filter(
-                key=validated_data["key"], team_id=self.context["team_id"], deleted=True
+                key=validated_data["key"], team__project_id=self.context["project_id"], deleted=True
             ).delete()
         except deletion.RestrictedError:
             raise exceptions.ValidationError(
@@ -382,7 +385,9 @@ def update(self, instance: FeatureFlag, validated_data: dict, *args: Any, **kwar
         request = self.context["request"]
         validated_key = validated_data.get("key", None)
         if validated_key:
-            FeatureFlag.objects.filter(key=validated_key, team=instance.team, deleted=True).delete()
+            FeatureFlag.objects.filter(
+                key=validated_key, team__project_id=instance.team.project_id, deleted=True
+            ).delete()
         self._update_filters(validated_data)
 
         analytics_dashboards = validated_data.pop("analytics_dashboards", None)
@@ -393,6 +398,23 @@ def update(self, instance: FeatureFlag, validated_data: dict, *args: Any, **kwar
 
         instance = super().update(instance, validated_data)
 
+        # Propagate the new variants and aggregation group type index to the linked experiments
+        if "filters" in validated_data:
+            filters = validated_data["filters"] or {}
+            multivariate = filters.get("multivariate") or {}
+            variants = multivariate.get("variants", [])
+            aggregation_group_type_index = filters.get("aggregation_group_type_index")
+
+            for experiment in instance.experiment_set.all():
+                if experiment.parameters is None:
+                    experiment.parameters = {}
+                experiment.parameters["feature_flag_variants"] = variants
+                if aggregation_group_type_index is not None:
+                    experiment.parameters["aggregation_group_type_index"] = aggregation_group_type_index
+                else:
+                    experiment.parameters.pop("aggregation_group_type_index", None)
+                experiment.save()
+
         report_user_action(request.user, "feature flag updated", instance.get_analytics_metadata())
 
         return instance
@@ -499,11 +521,11 @@ def safely_get_queryset(self, queryset) -> QuerySet:
                 .prefetch_related("surveys_linked_flag")
             )
 
-            survey_targeting_flags = Survey.objects.filter(team=self.team, targeting_flag__isnull=False).values_list(
-                "targeting_flag_id", flat=True
-            )
+            survey_targeting_flags = Survey.objects.filter(
+                team__project_id=self.team.project_id, targeting_flag__isnull=False
+            ).values_list("targeting_flag_id", flat=True)
             survey_internal_targeting_flags = Survey.objects.filter(
-                team=self.team, internal_targeting_flag__isnull=False
+                team__project_id=self.team.project_id, internal_targeting_flag__isnull=False
             ).values_list("internal_targeting_flag_id", flat=True)
             queryset = queryset.exclude(Q(id__in=survey_targeting_flags)).exclude(
                 Q(id__in=survey_internal_targeting_flags)
@@ -630,7 +652,9 @@ def my_flags(self, request: request.Request, **kwargs):
         if not request.user.is_authenticated:  # for mypy
             raise exceptions.NotAuthenticated()
 
-        feature_flags = list(FeatureFlag.objects.filter(team=self.team, deleted=False).order_by("-created_at"))
+        feature_flags = list(
+            FeatureFlag.objects.filter(team__project_id=self.team.project_id, deleted=False).order_by("-created_at")
+        )
 
         if not feature_flags:
             return Response([])
@@ -666,7 +690,7 @@ def local_evaluation(self, request: request.Request, **kwargs):
             seen_cohorts_cache = {
                 cohort.pk: cohort
                 for cohort in Cohort.objects.db_manager(DATABASE_FOR_LOCAL_EVALUATION).filter(
-                    team_id=self.team_id, deleted=False
+                    team__project_id=self.project_id, deleted=False
                 )
             }
 
@@ -729,7 +753,7 @@ def local_evaluation(self, request: request.Request, **kwargs):
                 "group_type_mapping": {
                     str(row.group_type_index): row.group_type
                     for row in GroupTypeMapping.objects.db_manager(DATABASE_FOR_LOCAL_EVALUATION).filter(
-                        team_id=self.team_id
+                        project_id=self.project_id
                     )
                 },
                 "cohorts": cohorts,
@@ -754,9 +778,9 @@ def evaluation_reasons(self, request: request.Request, **kwargs):
                 "evaluation": reasons[flag_key],
             }
 
-        disabled_flags = FeatureFlag.objects.filter(team_id=self.team_id, active=False, deleted=False).values_list(
-            "key", flat=True
-        )
+        disabled_flags = FeatureFlag.objects.filter(
+            team__project_id=self.project_id, active=False, deleted=False
+        ).values_list("key", flat=True)
 
         for flag_key in disabled_flags:
             flags_with_evaluation_reasons[flag_key] = {
@@ -819,13 +843,27 @@ def all_activity(self, request: request.Request, **kwargs):
 
         return activity_page_response(activity_page, limit, page, request)
 
+    @action(methods=["GET"], detail=True, required_scopes=["feature_flag:read"])
+    def status(self, request: request.Request, **kwargs):
+        feature_flag_id = kwargs["pk"]
+
+        checker = FeatureFlagStatusChecker(
+            feature_flag_id=feature_flag_id,
+        )
+        flag_status, reason = checker.get_status()
+
+        return Response(
+            {"status": flag_status, "reason": reason},
+            status=status.HTTP_404_NOT_FOUND if flag_status == FeatureFlagStatus.UNKNOWN else status.HTTP_200_OK,
+        )
+
     @action(methods=["GET"], detail=True, required_scopes=["activity_log:read"])
     def activity(self, request: request.Request, **kwargs):
         limit = int(request.query_params.get("limit", "10"))
         page = int(request.query_params.get("page", "1"))
 
         item_id = kwargs["pk"]
-        if not FeatureFlag.objects.filter(id=item_id, team_id=self.team_id).exists():
+        if not FeatureFlag.objects.filter(id=item_id, team__project_id=self.project_id).exists():
             return Response("", status=status.HTTP_404_NOT_FOUND)
 
         activity_page = load_activity(
diff --git a/posthog/api/hog_function.py b/posthog/api/hog_function.py
index 339400a45aa78..4549f4f3a8bb5 100644
--- a/posthog/api/hog_function.py
+++ b/posthog/api/hog_function.py
@@ -107,6 +107,7 @@ class Meta:
             "inputs",
             "filters",
             "masking",
+            "mappings",
             "icon_url",
             "template",
             "template_id",
@@ -127,8 +128,19 @@ class Meta:
             "inputs_schema": {"required": False},
             "template_id": {"write_only": True},
             "deleted": {"write_only": True},
+            "type": {"required": True},
         }
 
+    def validate_type(self, value):
+        # Ensure it is only set when creating a new function
+        if self.context.get("view") and self.context["view"].action == "create":
+            return value
+
+        instance = cast(Optional[HogFunction], self.context.get("instance", self.instance))
+        if instance and instance.type != value:
+            raise serializers.ValidationError("Cannot modify the type of an existing function")
+        return value
+
     def validate(self, attrs):
         team = self.context["get_team"]()
         attrs["team"] = team
@@ -136,6 +148,8 @@ def validate(self, attrs):
         has_addon = team.organization.is_feature_available(AvailableFeature.DATA_PIPELINES)
         instance = cast(Optional[HogFunction], self.context.get("instance", self.instance))
 
+        hog_type = attrs.get("type", instance.type if instance else "destination")
+
         if not has_addon:
             template_id = attrs.get("template_id", instance.template_id if instance else None)
             template = HOG_FUNCTION_TEMPLATES_BY_ID.get(template_id, None)
@@ -153,54 +167,66 @@ def validate(self, attrs):
 
             # Without the addon, they cannot deviate from the template
             attrs["inputs_schema"] = template.inputs_schema
+            attrs["mappings"] = template.mappings
             attrs["hog"] = template.hog
 
-        if "type" not in attrs:
-            attrs["type"] = "destination"
-
         if self.context.get("view") and self.context["view"].action == "create":
             # Ensure we have sensible defaults when created
             attrs["filters"] = attrs.get("filters") or {}
             attrs["inputs_schema"] = attrs.get("inputs_schema") or []
             attrs["inputs"] = attrs.get("inputs") or {}
+            attrs["mappings"] = attrs.get("mappings") or None
+
+        # Used for both top level input validation, and mappings input validation
+        def validate_input_and_filters(attrs: dict):
+            if "inputs_schema" in attrs:
+                attrs["inputs_schema"] = validate_inputs_schema(attrs["inputs_schema"])
+
+            if "inputs" in attrs:
+                inputs = attrs["inputs"] or {}
+                existing_encrypted_inputs = None
 
-        if "inputs_schema" in attrs:
-            attrs["inputs_schema"] = validate_inputs_schema(attrs["inputs_schema"])
+                if instance and instance.encrypted_inputs:
+                    existing_encrypted_inputs = instance.encrypted_inputs
 
-        if "inputs" in attrs:
-            inputs = attrs["inputs"] or {}
-            existing_encrypted_inputs = None
+                attrs["inputs_schema"] = attrs.get("inputs_schema", instance.inputs_schema if instance else [])
+                attrs["inputs"] = validate_inputs(attrs["inputs_schema"], inputs, existing_encrypted_inputs, hog_type)
 
-            if instance and instance.encrypted_inputs:
-                existing_encrypted_inputs = instance.encrypted_inputs
+            if "filters" in attrs:
+                if hog_type in TYPES_WITH_COMPILED_FILTERS:
+                    attrs["filters"] = compile_filters_bytecode(attrs["filters"], team)
+                elif hog_type in TYPES_WITH_TRANSPILED_FILTERS:
+                    compiler = JavaScriptCompiler()
+                    code = compiler.visit(compile_filters_expr(attrs["filters"], team))
+                    attrs["filters"]["transpiled"] = {"lang": "ts", "code": code, "stl": list(compiler.stl_functions)}
+                    if "bytecode" in attrs["filters"]:
+                        del attrs["filters"]["bytecode"]
 
-            attrs["inputs_schema"] = attrs.get("inputs_schema", instance.inputs_schema if instance else [])
-            attrs["inputs"] = validate_inputs(attrs["inputs_schema"], inputs, existing_encrypted_inputs, attrs["type"])
+        validate_input_and_filters(attrs)
 
-        if "filters" in attrs:
-            if attrs["type"] in TYPES_WITH_COMPILED_FILTERS:
-                attrs["filters"] = compile_filters_bytecode(attrs["filters"], team)
-            elif attrs["type"] in TYPES_WITH_TRANSPILED_FILTERS:
-                compiler = JavaScriptCompiler()
-                code = compiler.visit(compile_filters_expr(attrs["filters"], team))
-                attrs["filters"]["transpiled"] = {"lang": "ts", "code": code, "stl": list(compiler.stl_functions)}
-                if "bytecode" in attrs["filters"]:
-                    del attrs["filters"]["bytecode"]
+        if attrs.get("mappings", None) is not None:
+            if hog_type != "site_destination":
+                raise serializers.ValidationError({"mappings": "Mappings are only allowed for site destinations."})
+            for mapping in attrs["mappings"]:
+                validate_input_and_filters(mapping)
 
         if "hog" in attrs:
-            if attrs["type"] in TYPES_WITH_JAVASCRIPT_SOURCE:
-                # Upon creation, this code will be run before the model has an "id".
-                # If that's the case, the code just makes sure transpilation doesn't throw. We'll re-transpile after creation.
-                id = str(instance.id) if instance else "__"
+            if hog_type in TYPES_WITH_JAVASCRIPT_SOURCE:
                 try:
+                    # Validate transpilation using the model instance
                     attrs["transpiled"] = get_transpiled_function(
-                        id, attrs["hog"], attrs["filters"], attrs["inputs"], team
+                        HogFunction(
+                            team=team,
+                            hog=attrs["hog"],
+                            filters=attrs["filters"],
+                            inputs=attrs["inputs"],
+                        )
                     )
                 except TranspilerError:
-                    raise serializers.ValidationError({"hog": f"Error in TypeScript code"})
+                    raise serializers.ValidationError({"hog": "Error in TypeScript code"})
                 attrs["bytecode"] = None
             else:
-                attrs["bytecode"] = compile_hog(attrs["hog"])
+                attrs["bytecode"] = compile_hog(attrs["hog"], hog_type)
                 attrs["transpiled"] = None
         else:
             attrs["bytecode"] = None
@@ -231,11 +257,7 @@ def create(self, validated_data: dict, *args, **kwargs) -> HogFunction:
         request = self.context["request"]
         validated_data["created_by"] = request.user
         hog_function = super().create(validated_data=validated_data)
-        if validated_data.get("type") in TYPES_WITH_JAVASCRIPT_SOURCE:
-            # Re-run the transpilation now that we have an ID
-            hog_function.transpiled = get_transpiled_function(
-                str(hog_function.id), hog_function.hog, hog_function.filters, hog_function.inputs, hog_function.team
-            )
+
         return hog_function
 
     def update(self, instance: HogFunction, validated_data: dict, *args, **kwargs) -> HogFunction:
diff --git a/posthog/api/hog_function_template.py b/posthog/api/hog_function_template.py
index 2044affa77075..38641031167ad 100644
--- a/posthog/api/hog_function_template.py
+++ b/posthog/api/hog_function_template.py
@@ -6,19 +6,36 @@
 from rest_framework.exceptions import NotFound
 
 from posthog.cdp.templates import HOG_FUNCTION_TEMPLATES
-from posthog.cdp.templates.hog_function_template import HogFunctionTemplate, HogFunctionSubTemplate
+from posthog.cdp.templates.hog_function_template import (
+    HogFunctionMapping,
+    HogFunctionMappingTemplate,
+    HogFunctionTemplate,
+    HogFunctionSubTemplate,
+)
 from rest_framework_dataclasses.serializers import DataclassSerializer
 
 
 logger = structlog.get_logger(__name__)
 
 
+class HogFunctionMappingSerializer(DataclassSerializer):
+    class Meta:
+        dataclass = HogFunctionMapping
+
+
+class HogFunctionMappingTemplateSerializer(DataclassSerializer):
+    class Meta:
+        dataclass = HogFunctionMappingTemplate
+
+
 class HogFunctionSubTemplateSerializer(DataclassSerializer):
     class Meta:
         dataclass = HogFunctionSubTemplate
 
 
 class HogFunctionTemplateSerializer(DataclassSerializer):
+    mapping_templates = HogFunctionMappingTemplateSerializer(many=True, required=False)
+    mappings = HogFunctionMappingSerializer(many=True, required=False)
     sub_templates = HogFunctionSubTemplateSerializer(many=True, required=False)
 
     class Meta:
diff --git a/posthog/api/insight.py b/posthog/api/insight.py
index 32c24b3979f44..22b53f07e73af 100644
--- a/posthog/api/insight.py
+++ b/posthog/api/insight.py
@@ -1184,7 +1184,7 @@ def activity(self, request: request.Request, **kwargs):
         page = int(request.query_params.get("page", "1"))
 
         item_id = kwargs["pk"]
-        if not Insight.objects.filter(id=item_id, team_id=self.team_id).exists():
+        if not Insight.objects.filter(id=item_id, team__project_id=self.team.project_id).exists():
             return Response("", status=status.HTTP_404_NOT_FOUND)
 
         activity_page = load_activity(
diff --git a/posthog/api/metalytics.py b/posthog/api/metalytics.py
new file mode 100644
index 0000000000000..c4ae502786654
--- /dev/null
+++ b/posthog/api/metalytics.py
@@ -0,0 +1,43 @@
+from typing import Any
+
+from posthog.kafka_client.client import KafkaProducer
+from posthog.kafka_client.topics import KAFKA_APP_METRICS2
+from posthog.models.event.util import format_clickhouse_timestamp
+from posthog.utils import cast_timestamp_or_now
+from posthog.api.routing import TeamAndOrgViewSetMixin
+
+from rest_framework import request, response, viewsets, serializers
+from rest_framework.serializers import BaseSerializer
+
+from posthog.models.plugin import PluginConfig
+
+
+class MetalyticsCreateRequestSerializer(serializers.Serializer):
+    metric_name = serializers.ChoiceField(choices=["viewed"], required=True)
+    instance_id = serializers.CharField(required=True)
+
+
+class MetalyticsViewSet(TeamAndOrgViewSetMixin, viewsets.GenericViewSet):
+    scope_object = "INTERNAL"
+    queryset = PluginConfig.objects.all()
+
+    def get_serializer_class(self) -> type[BaseSerializer]:
+        return MetalyticsCreateRequestSerializer if self.action == "create" else MetalyticsCreateRequestSerializer
+
+    def create(self, request: request.Request, *args: Any, **kwargs: Any) -> response.Response:
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        validated_data = serializer.validated_data
+
+        payload = {
+            **validated_data,
+            "team_id": self.team_id,
+            "app_source_id": self.request.user.pk,
+            "app_source": "metalytics",
+            "count": 1,
+            "timestamp": format_clickhouse_timestamp(cast_timestamp_or_now(None)),
+        }
+
+        KafkaProducer().produce(topic=KAFKA_APP_METRICS2, data=payload)
+
+        return response.Response({})
diff --git a/posthog/api/organization.py b/posthog/api/organization.py
index c522ca164c0b9..6fe798479dd7b 100644
--- a/posthog/api/organization.py
+++ b/posthog/api/organization.py
@@ -5,6 +5,8 @@
 from django.shortcuts import get_object_or_404
 from rest_framework import exceptions, permissions, serializers, viewsets
 from rest_framework.request import Request
+from rest_framework.response import Response
+import posthoganalytics
 
 from posthog import settings
 from posthog.api.routing import TeamAndOrgViewSetMixin
@@ -12,7 +14,7 @@
 from posthog.auth import PersonalAPIKeyAuthentication
 from posthog.cloud_utils import is_cloud
 from posthog.constants import INTERNAL_BOT_EMAIL_SUFFIX, AvailableFeature
-from posthog.event_usage import report_organization_deleted
+from posthog.event_usage import report_organization_deleted, groups
 from posthog.models import Organization, User
 from posthog.models.async_deletion import AsyncDeletion, DeletionType
 from posthog.rbac.user_access_control import UserAccessControlSerializerMixin
@@ -240,3 +242,24 @@ def get_serializer_context(self) -> dict[str, Any]:
             **super().get_serializer_context(),
             "user_permissions": UserPermissions(cast(User, self.request.user)),
         }
+
+    def update(self, request: Request, *args: Any, **kwargs: Any) -> Response:
+        if "enforce_2fa" in request.data:
+            enforce_2fa_value = request.data["enforce_2fa"]
+            organization = self.get_object()
+            user = cast(User, request.user)
+
+            # Add capture event for 2FA enforcement change
+            posthoganalytics.capture(
+                str(user.distinct_id),
+                "organization 2fa enforcement toggled",
+                properties={
+                    "enabled": enforce_2fa_value,
+                    "organization_id": str(organization.id),
+                    "organization_name": organization.name,
+                    "user_role": user.organization_memberships.get(organization=organization).level,
+                },
+                groups=groups(organization),
+            )
+
+        return super().update(request, *args, **kwargs)
diff --git a/posthog/api/organization_domain.py b/posthog/api/organization_domain.py
index e39b611c1fb32..d563c5dd3edf3 100644
--- a/posthog/api/organization_domain.py
+++ b/posthog/api/organization_domain.py
@@ -1,5 +1,6 @@
 import re
 from typing import Any, cast
+import posthoganalytics
 
 from rest_framework import exceptions, request, response, serializers
 from posthog.api.utils import action
@@ -11,10 +12,29 @@
 from posthog.models import OrganizationDomain
 from posthog.models.organization import Organization
 from posthog.permissions import OrganizationAdminWritePermissions
+from posthog.event_usage import groups
 
 DOMAIN_REGEX = r"^([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}$"
 
 
+def _capture_domain_event(request, domain: OrganizationDomain, event_type: str, properties: dict | None = None) -> None:
+    if not properties:
+        properties = {}
+
+    properties.update(
+        {
+            "domain": domain.domain,
+        }
+    )
+
+    posthoganalytics.capture(
+        request.user.distinct_id,
+        f"organization domain {event_type}",
+        properties=properties,
+        groups=groups(domain.organization),
+    )
+
+
 class OrganizationDomainSerializer(serializers.ModelSerializer):
     UPDATE_ONLY_WHEN_VERIFIED = ["jit_provisioning_enabled", "sso_enforcement"]
 
@@ -96,3 +116,38 @@ def verify(self, request: request.Request, **kw) -> response.Response:
 
         serializer = self.get_serializer(instance=instance)
         return response.Response(serializer.data)
+
+    def create(self, request: request.Request, *args: Any, **kwargs: Any) -> response.Response:
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        instance = serializer.save()
+
+        _capture_domain_event(
+            request,
+            instance,
+            "created",
+            properties={
+                "jit_provisioning_enabled": instance.jit_provisioning_enabled,
+                "sso_enforcement": instance.sso_enforcement or None,
+            },
+        )
+
+        return response.Response(serializer.data, status=201)
+
+    def destroy(self, request: request.Request, *args: Any, **kwargs: Any) -> response.Response:
+        instance = self.get_object()
+
+        _capture_domain_event(
+            request,
+            instance,
+            "deleted",
+            properties={
+                "is_verified": instance.is_verified,
+                "had_saml": instance.has_saml,
+                "had_jit_provisioning": instance.jit_provisioning_enabled,
+                "had_sso_enforcement": bool(instance.sso_enforcement),
+            },
+        )
+
+        instance.delete()
+        return response.Response(status=204)
diff --git a/posthog/api/organization_feature_flag.py b/posthog/api/organization_feature_flag.py
index 3585f5f149849..c86781fc87876 100644
--- a/posthog/api/organization_feature_flag.py
+++ b/posthog/api/organization_feature_flag.py
@@ -1,4 +1,3 @@
-from django.core.exceptions import ObjectDoesNotExist
 from rest_framework.response import Response
 from posthog.api.utils import action
 from rest_framework import (
@@ -66,7 +65,7 @@ def copy_flags(self, request, *args, **kwargs):
 
         # Fetch the flag to copy
         try:
-            flag_to_copy = FeatureFlag.objects.get(key=feature_flag_key, team_id=from_project)
+            flag_to_copy = FeatureFlag.objects.get(key=feature_flag_key, team__project_id=from_project)
         except FeatureFlag.DoesNotExist:
             return Response({"error": "Feature flag to copy does not exist."}, status=status.HTTP_400_BAD_REQUEST)
 
@@ -82,9 +81,8 @@ def copy_flags(self, request, *args, **kwargs):
 
         for target_project_id in target_project_ids:
             # Target project does not exist
-            try:
-                target_project = Team.objects.get(id=target_project_id)
-            except ObjectDoesNotExist:
+            target_team = Team.objects.filter(project_id=target_project_id).first()
+            if target_team is None:
                 failed_projects.append(
                     {
                         "project_id": target_project_id,
@@ -111,7 +109,7 @@ def copy_flags(self, request, *args, **kwargs):
 
                     # search in destination project by name
                     destination_cohort = Cohort.objects.filter(
-                        name=original_cohort.name, team_id=target_project_id, deleted=False
+                        name=original_cohort.name, team__project_id=target_project_id, deleted=False
                     ).first()
 
                     # create new cohort in the destination project
@@ -134,7 +132,7 @@ def copy_flags(self, request, *args, **kwargs):
 
                         destination_cohort_serializer = CohortSerializer(
                             data={
-                                "team": target_project,
+                                "team": target_team,
                                 "name": original_cohort.name,
                                 "groups": [],
                                 "filters": {"properties": prop_group.to_dict()},
@@ -143,7 +141,7 @@ def copy_flags(self, request, *args, **kwargs):
                             },
                             context={
                                 "request": request,
-                                "team_id": target_project.id,
+                                "team_id": target_team.id,
                             },
                         )
                         destination_cohort_serializer.is_valid(raise_exception=True)
@@ -183,7 +181,7 @@ def copy_flags(self, request, *args, **kwargs):
             }
 
             existing_flag = FeatureFlag.objects.filter(
-                key=feature_flag_key, team_id=target_project_id, deleted=False
+                key=feature_flag_key, team__project_id=target_project_id, deleted=False
             ).first()
             # Update existing flag
             if existing_flag:
diff --git a/posthog/api/project.py b/posthog/api/project.py
index 9bc0d91cec45f..b3b808f520430 100644
--- a/posthog/api/project.py
+++ b/posthog/api/project.py
@@ -191,7 +191,7 @@ def get_effective_membership_level(self, project: Project) -> Optional[Organizat
         return self.user_permissions.team(team).effective_membership_level
 
     def get_has_group_types(self, project: Project) -> bool:
-        return GroupTypeMapping.objects.filter(team_id=project.id).exists()
+        return GroupTypeMapping.objects.filter(project_id=project.id).exists()
 
     def get_live_events_token(self, project: Project) -> Optional[str]:
         team = project.teams.get(pk=project.pk)
diff --git a/posthog/api/query.py b/posthog/api/query.py
index be36aafc3e789..51e8d2450def9 100644
--- a/posthog/api/query.py
+++ b/posthog/api/query.py
@@ -1,19 +1,15 @@
 import re
 import uuid
-from typing import cast
 
-from django.http import JsonResponse, StreamingHttpResponse
+from django.http import JsonResponse
 from drf_spectacular.utils import OpenApiResponse
 from pydantic import BaseModel
 from rest_framework import status, viewsets
 from rest_framework.exceptions import NotAuthenticated, ValidationError
-from rest_framework.renderers import BaseRenderer
 from rest_framework.request import Request
 from rest_framework.response import Response
 from sentry_sdk import capture_exception, set_tag
 
-from ee.hogai.assistant import Assistant
-from ee.hogai.utils import Conversation
 from posthog.api.documentation import extend_schema
 from posthog.api.mixins import PydanticModelMixin
 from posthog.api.monitoring import Feature, monitor
@@ -48,14 +44,6 @@
 )
 
 
-class ServerSentEventRenderer(BaseRenderer):
-    media_type = "text/event-stream"
-    format = "txt"
-
-    def render(self, data, accepted_media_type=None, renderer_context=None):
-        return data
-
-
 class QueryViewSet(TeamAndOrgViewSetMixin, PydanticModelMixin, viewsets.ViewSet):
     # NOTE: Do we need to override the scopes for the "create"
     scope_object = "query"
@@ -65,7 +53,7 @@ class QueryViewSet(TeamAndOrgViewSetMixin, PydanticModelMixin, viewsets.ViewSet)
     sharing_enabled_actions = ["retrieve"]
 
     def get_throttles(self):
-        if self.action in ("draft_sql", "chat"):
+        if self.action == "draft_sql":
             return [AIBurstRateThrottle(), AISustainedRateThrottle()]
         if query := self.request.data.get("query"):
             if isinstance(query, dict) and query.get("kind") == "HogQLQuery":
@@ -179,13 +167,6 @@ def draft_sql(self, request: Request, *args, **kwargs) -> Response:
             raise ValidationError({"prompt": [str(e)]}, code="unclear")
         return Response({"sql": result})
 
-    @action(detail=False, methods=["POST"], renderer_classes=[ServerSentEventRenderer])
-    def chat(self, request: Request, *args, **kwargs):
-        assert request.user is not None
-        validated_body = Conversation.model_validate(request.data)
-        assistant = Assistant(self.team, validated_body, cast(User, request.user))
-        return StreamingHttpResponse(assistant.stream(), content_type=ServerSentEventRenderer.media_type)
-
     def handle_column_ch_error(self, error):
         if getattr(error, "message", None):
             match = re.search(r"There's no column.*in table", error.message)
diff --git a/posthog/api/remote_config.py b/posthog/api/remote_config.py
new file mode 100644
index 0000000000000..ba62347c8a77c
--- /dev/null
+++ b/posthog/api/remote_config.py
@@ -0,0 +1,58 @@
+import re
+from django.http import JsonResponse, Http404, HttpResponse
+from rest_framework.exceptions import ValidationError
+from rest_framework.views import APIView
+from posthog.models.remote_config import RemoteConfig
+
+
+def add_vary_headers(response):
+    """
+    Add Vary headers for Origin and Referer to responses.
+    """
+    response["Vary"] = "Origin, Referer"
+    return response
+
+
+class BaseRemoteConfigAPIView(APIView):
+    """
+    Base class for RemoteConfig API views.
+    """
+
+    authentication_classes = []
+    permission_classes = []
+
+    def check_token(self, token: str):
+        # Most tokens are phc_xxx but there are some older ones that are random strings including underscores and dashes
+        if len(token) > 200 or not re.match(r"^[a-zA-Z0-9_-]+$", token):
+            raise ValidationError("Invalid token")
+        return token
+
+
+class RemoteConfigAPIView(BaseRemoteConfigAPIView):
+    def get(self, request, token: str, *args, **kwargs):
+        try:
+            resource = RemoteConfig.get_config_via_token(self.check_token(token), request=request)
+        except RemoteConfig.DoesNotExist:
+            raise Http404()
+
+        return add_vary_headers(JsonResponse(resource))
+
+
+class RemoteConfigJSAPIView(BaseRemoteConfigAPIView):
+    def get(self, request, token: str, *args, **kwargs):
+        try:
+            script_content = RemoteConfig.get_config_js_via_token(self.check_token(token), request=request)
+        except RemoteConfig.DoesNotExist:
+            raise Http404()
+
+        return add_vary_headers(HttpResponse(script_content, content_type="application/javascript"))
+
+
+class RemoteConfigArrayJSAPIView(BaseRemoteConfigAPIView):
+    def get(self, request, token: str, *args, **kwargs):
+        try:
+            script_content = RemoteConfig.get_array_js_via_token(self.check_token(token), request=request)
+        except RemoteConfig.DoesNotExist:
+            raise Http404()
+
+        return add_vary_headers(HttpResponse(script_content, content_type="application/javascript"))
diff --git a/posthog/api/sharing.py b/posthog/api/sharing.py
index d0cf5af56bafd..ca931c526248d 100644
--- a/posthog/api/sharing.py
+++ b/posthog/api/sharing.py
@@ -99,12 +99,12 @@ def get_serializer_context(
 
         if dashboard_id:
             try:
-                context["dashboard"] = Dashboard.objects.get(id=dashboard_id, team=self.team)
+                context["dashboard"] = Dashboard.objects.get(id=dashboard_id, team__project_id=self.team.project_id)
             except Dashboard.DoesNotExist:
                 raise NotFound("Dashboard not found.")
         if insight_id:
             try:
-                context["insight"] = Insight.objects.get(id=insight_id, team=self.team)
+                context["insight"] = Insight.objects.get(id=insight_id, team__project_id=self.team.project_id)
             except Insight.DoesNotExist:
                 raise NotFound("Insight not found.")
         if recording_id:
diff --git a/posthog/api/site_app.py b/posthog/api/site_app.py
index 40e1df08ea778..ee43c9b14f61b 100644
--- a/posthog/api/site_app.py
+++ b/posthog/api/site_app.py
@@ -1,5 +1,4 @@
 import json
-
 from django.http import HttpRequest, HttpResponse
 from django.views.decorators.csrf import csrf_exempt
 from rest_framework import status
@@ -8,8 +7,7 @@
 
 from posthog.exceptions import generate_exception_response
 from posthog.logging.timing import timed
-from posthog.models.hog_functions.hog_function import HogFunction
-from posthog.plugins.site import get_site_config_from_schema, get_transpiled_site_source
+from posthog.plugins.site import get_transpiled_site_source, get_site_config_from_schema
 
 
 @csrf_exempt
@@ -37,34 +35,3 @@ def get_site_app(request: HttpRequest, id: int, token: str, hash: str) -> HttpRe
             type="server_error",
             status_code=status.HTTP_404_NOT_FOUND,
         )
-
-
-@csrf_exempt
-@timed("posthog_cloud_site_app_endpoint")
-def get_site_function(request: HttpRequest, id: str, hash: str) -> HttpResponse:
-    try:
-        # TODO: Should we add a token as well? Is the UUID enough?
-        function = (
-            HogFunction.objects.filter(
-                id=id, enabled=True, type__in=("site_destination", "site_app"), transpiled__isnull=False
-            )
-            .values_list("transpiled")
-            .first()
-        )
-        if not function:
-            raise Exception("No function found")
-
-        response = HttpResponse(content=function[0], content_type="application/javascript")
-        response["Cache-Control"] = "public, max-age=31536000"  # Cache for 1 year
-        statsd.incr(f"posthog_cloud_raw_endpoint_success", tags={"endpoint": "site_function"})
-        return response
-    except Exception as e:
-        capture_exception(e, {"data": {"id": id}})
-        statsd.incr("posthog_cloud_raw_endpoint_failure", tags={"endpoint": "site_function"})
-        return generate_exception_response(
-            "site_function",
-            "Unable to serve site function source code.",
-            code="missing_site_function_source",
-            type="server_error",
-            status_code=status.HTTP_404_NOT_FOUND,
-        )
diff --git a/posthog/api/survey.py b/posthog/api/survey.py
index 3d13981a867f4..835860bb00906 100644
--- a/posthog/api/survey.py
+++ b/posthog/api/survey.py
@@ -19,7 +19,7 @@
 from rest_framework.response import Response
 
 from ee.surveys.summaries.summarize_surveys import summarize_survey_responses
-from posthog.api.action import ActionSerializer
+from posthog.api.action import ActionSerializer, ActionStepJSONSerializer
 from posthog.api.feature_flag import (
     BEHAVIOURAL_COHORT_FOUND_ERROR_CODE,
     FeatureFlagSerializer,
@@ -212,7 +212,7 @@ def validate_conditions(self, value):
             return value
 
         action_ids = (value.get("id") for value in values)
-        project_actions = Action.objects.filter(team_id=self.context["team_id"], id__in=action_ids)
+        project_actions = Action.objects.filter(team__project_id=self.context["project_id"], id__in=action_ids)
 
         for project_action in project_actions:
             for step in project_action.steps:
@@ -291,7 +291,7 @@ def validate(self, data):
 
         if (
             self.context["request"].method == "POST"
-            and Survey.objects.filter(name=data.get("name"), team_id=self.context["team_id"]).exists()
+            and Survey.objects.filter(name=data.get("name"), team__project_id=self.context["project_id"]).exists()
         ):
             raise serializers.ValidationError("There is already a survey with this name.", code="unique")
 
@@ -300,7 +300,7 @@ def validate(self, data):
         if (
             existing_survey
             and existing_survey.name != data.get("name")
-            and Survey.objects.filter(name=data.get("name"), team_id=self.context["team_id"])
+            and Survey.objects.filter(name=data.get("name"), team__project_id=self.context["project_id"])
             .exclude(id=existing_survey.id)
             .exists()
         ):
@@ -325,7 +325,7 @@ def validate(self, data):
             if response_sampling_start_date < today_utc:
                 raise serializers.ValidationError(
                     {
-                        "response_sampling_start_date": "Response sampling start date must be today or a future date in UTC."
+                        "response_sampling_start_date": f"Response sampling start date must be today or a future date in UTC. Got {response_sampling_start_date} when current time is {today_utc}"
                     }
                 )
 
@@ -562,7 +562,7 @@ def _associate_actions(self, instance: Survey, conditions):
 
         action_ids = (value.get("id") for value in values)
 
-        instance.actions.set(Action.objects.filter(team_id=self.context["team_id"], id__in=action_ids))
+        instance.actions.set(Action.objects.filter(team__project_id=self.context["project_id"], id__in=action_ids))
         instance.save()
 
     def _add_user_survey_interacted_filters(self, instance: Survey, end_date=None):
@@ -686,9 +686,9 @@ def destroy(self, request: Request, *args: Any, **kwargs: Any) -> Response:
 
     @action(methods=["GET"], detail=False, required_scopes=["survey:read"])
     def responses_count(self, request: request.Request, **kwargs):
-        earliest_survey_start_date = Survey.objects.filter(team_id=self.team_id).aggregate(Min("start_date"))[
-            "start_date__min"
-        ]
+        earliest_survey_start_date = Survey.objects.filter(team__project_id=self.project_id).aggregate(
+            Min("start_date")
+        )["start_date__min"]
         data = sync_execute(
             f"""
             SELECT JSONExtractString(properties, '$survey_id') as survey_id, count()
@@ -721,7 +721,7 @@ def activity(self, request: request.Request, **kwargs):
 
         item_id = kwargs["pk"]
 
-        if not Survey.objects.filter(id=item_id, team_id=self.team_id).exists():
+        if not Survey.objects.filter(id=item_id, team__project_id=self.project_id).exists():
             return Response(status=status.HTTP_404_NOT_FOUND)
 
         activity_page = load_activity(
@@ -742,7 +742,7 @@ def summarize_responses(self, request: request.Request, **kwargs):
 
         survey_id = kwargs["pk"]
 
-        if not Survey.objects.filter(id=survey_id, team_id=self.team_id).exists():
+        if not Survey.objects.filter(id=survey_id, team__project_id=self.project_id).exists():
             return Response(status=status.HTTP_404_NOT_FOUND)
 
         survey = self.get_object()
@@ -801,6 +801,19 @@ class Meta:
         fields = ["survey_config"]
 
 
+class SurveyAPIActionSerializer(serializers.ModelSerializer):
+    steps = ActionStepJSONSerializer(many=True, required=False)
+
+    class Meta:
+        model = Action
+        fields = [
+            "id",
+            "name",
+            "steps",
+        ]
+        read_only_fields = fields
+
+
 class SurveyAPISerializer(serializers.ModelSerializer):
     """
     Serializer for the exposed /api/surveys endpoint, to be used in posthog-js and for headless APIs.
@@ -844,10 +857,29 @@ def get_conditions(self, survey: Survey):
             if survey.conditions is None:
                 survey.conditions = {}
 
-            survey.conditions["actions"] = {"values": ActionSerializer(actions, many=True).data}
+            survey.conditions["actions"] = {"values": SurveyAPIActionSerializer(actions, many=True).data}
         return survey.conditions
 
 
+def get_surveys_response(team: Team):
+    surveys = SurveyAPISerializer(
+        Survey.objects.filter(team_id=team.id)
+        .exclude(archived=True)
+        .select_related("linked_flag", "targeting_flag", "internal_targeting_flag")
+        .prefetch_related("actions"),
+        many=True,
+    ).data
+
+    serialized_survey_config: dict[str, Any] = {}
+    if team.survey_config is not None:
+        serialized_survey_config = SurveyConfigSerializer(team).data
+
+    return {
+        "surveys": surveys,
+        "survey_config": serialized_survey_config.get("survey_config", None),
+    }
+
+
 @csrf_exempt
 def surveys(request: Request):
     token = get_token(None, request)
@@ -879,27 +911,7 @@ def surveys(request: Request):
             ),
         )
 
-    surveys = SurveyAPISerializer(
-        Survey.objects.filter(team_id=team.id)
-        .exclude(archived=True)
-        .select_related("linked_flag", "targeting_flag", "internal_targeting_flag")
-        .prefetch_related("actions"),
-        many=True,
-    ).data
-
-    serialized_survey_config: dict[str, Any] = {}
-    if team.survey_config is not None:
-        serialized_survey_config = SurveyConfigSerializer(team).data
-
-    return cors_response(
-        request,
-        JsonResponse(
-            {
-                "surveys": surveys,
-                "survey_config": serialized_survey_config.get("survey_config", None),
-            }
-        ),
-    )
+    return cors_response(request, JsonResponse(get_surveys_response(team)))
 
 
 @contextmanager
diff --git a/posthog/api/team.py b/posthog/api/team.py
index f2486a68fe8a0..d2b9ca018dbdf 100644
--- a/posthog/api/team.py
+++ b/posthog/api/team.py
@@ -24,8 +24,6 @@
     load_activity,
     log_activity,
 )
-from posthog.rbac.access_control_api_mixin import AccessControlViewSetMixin
-from posthog.rbac.user_access_control import UserAccessControlSerializerMixin
 from posthog.models.activity_logging.activity_page import activity_page_response
 from posthog.models.async_deletion import AsyncDeletion, DeletionType
 from posthog.models.group_type_mapping import GroupTypeMapping
@@ -38,14 +36,16 @@
 from posthog.models.utils import UUIDT
 from posthog.permissions import (
     CREATE_ACTIONS,
-    APIScopePermission,
     AccessControlPermission,
+    APIScopePermission,
     OrganizationAdminWritePermissions,
     OrganizationMemberPermissions,
     TeamMemberLightManagementPermission,
     TeamMemberStrictManagementPermission,
     get_organization_from_view,
 )
+from posthog.rbac.access_control_api_mixin import AccessControlViewSetMixin
+from posthog.rbac.user_access_control import UserAccessControlSerializerMixin
 from posthog.user_permissions import UserPermissions, UserPermissionsSerializerMixin
 from posthog.utils import (
     get_instance_realm,
@@ -115,6 +115,7 @@ class Meta:
         model = Team
         fields = [
             "id",
+            "project_id",
             "uuid",
             "name",
             "api_token",
@@ -141,6 +142,7 @@ class Meta:
             "heatmaps_opt_in",
             "capture_dead_clicks",
         ]
+        read_only_fields = fields
 
 
 class TeamSerializer(serializers.ModelSerializer, UserPermissionsSerializerMixin, UserAccessControlSerializerMixin):
@@ -234,7 +236,7 @@ def get_effective_membership_level(self, team: Team) -> Optional[OrganizationMem
         return self.user_permissions.team(team).effective_membership_level
 
     def get_has_group_types(self, team: Team) -> bool:
-        return GroupTypeMapping.objects.filter(team_id=team.id).exists()
+        return GroupTypeMapping.objects.filter(project_id=team.project_id).exists()
 
     def get_live_events_token(self, team: Team) -> Optional[str]:
         return encode_jwt(
@@ -610,18 +612,28 @@ def add_product_intent(self, request: request.Request, *args, **kwargs):
         product_type = request.data.get("product_type")
         current_url = request.headers.get("Referer")
         session_id = request.headers.get("X-Posthog-Session-Id")
+        should_report_product_intent = False
 
         if not product_type:
             return response.Response({"error": "product_type is required"}, status=400)
 
         product_intent, created = ProductIntent.objects.get_or_create(team=team, product_type=product_type)
-        if not created:
+
+        if created:
+            # For new intents, check activation immediately but skip reporting
+            was_already_activated = product_intent.check_and_update_activation(skip_reporting=True)
+            # Only report the action if they haven't already activated
+            if isinstance(user, User) and not was_already_activated:
+                should_report_product_intent = True
+        else:
             if not product_intent.activated_at:
-                product_intent.check_and_update_activation()
+                is_activated = product_intent.check_and_update_activation()
+                if not is_activated:
+                    should_report_product_intent = True
             product_intent.updated_at = datetime.now(tz=UTC)
             product_intent.save()
 
-        if isinstance(user, User) and not product_intent.activated_at:
+        if should_report_product_intent and isinstance(user, User):
             report_user_action(
                 user,
                 "user showed product intent",
diff --git a/posthog/api/test/__snapshots__/test_api_docs.ambr b/posthog/api/test/__snapshots__/test_api_docs.ambr
index 42c03569e8f25..862d8507dbb75 100644
--- a/posthog/api/test/__snapshots__/test_api_docs.ambr
+++ b/posthog/api/test/__snapshots__/test_api_docs.ambr
@@ -34,7 +34,6 @@
     '/home/runner/work/posthog/posthog/posthog/api/event.py: Warning [EventViewSet]: could not derive type of path parameter "id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
     '/home/runner/work/posthog/posthog/posthog/api/event.py: Warning [EventViewSet]: could not derive type of path parameter "project_id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:project_id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
     "/home/runner/work/posthog/posthog/posthog/api/event_definition.py: Error [EventDefinitionViewSet]: exception raised while getting serializer. Hint: Is get_serializer_class() returning None or is get_queryset() not working without a request? Ignoring the view for now. (Exception: 'AnonymousUser' object has no attribute 'organization')",
-    '/home/runner/work/posthog/posthog/posthog/api/event_definition.py: Warning [EventDefinitionViewSet]: could not derive type of path parameter "project_id" because model "posthog.models.event_definition.EventDefinition" contained no such field. Consider annotating parameter with @extend_schema. Defaulting to "string".',
     '/home/runner/work/posthog/posthog/posthog/api/exports.py: Warning [ExportedAssetViewSet > ExportedAssetSerializer]: unable to resolve type hint for function "filename". Consider using a type hint or @extend_schema_field. Defaulting to string.',
     '/home/runner/work/posthog/posthog/posthog/api/exports.py: Warning [ExportedAssetViewSet > ExportedAssetSerializer]: unable to resolve type hint for function "has_content". Consider using a type hint or @extend_schema_field. Defaulting to string.',
     '/home/runner/work/posthog/posthog/posthog/api/exports.py: Warning [ExportedAssetViewSet]: could not derive type of path parameter "project_id" because model "posthog.models.exported_asset.ExportedAsset" contained no such field. Consider annotating parameter with @extend_schema. Defaulting to "string".',
@@ -55,14 +54,13 @@
     '/home/runner/work/posthog/posthog/posthog/api/organization.py: Warning [OrganizationViewSet > OrganizationSerializer]: unable to resolve type hint for function "get_metadata". Consider using a type hint or @extend_schema_field. Defaulting to string.',
     '/home/runner/work/posthog/posthog/posthog/api/person.py: Warning [SessionRecordingViewSet > SessionRecordingSerializer > MinimalPersonSerializer]: unable to resolve type hint for function "get_distinct_ids". Consider using a type hint or @extend_schema_field. Defaulting to string.',
     '/home/runner/work/posthog/posthog/posthog/api/plugin_log_entry.py: Warning [PluginLogEntryViewSet]: could not derive type of path parameter "plugin_config_id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:plugin_config_id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
+    '/home/runner/work/posthog/posthog/posthog/api/plugin_log_entry.py: Warning [PluginLogEntryViewSet]: could not derive type of path parameter "project_id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:project_id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
     '/home/runner/work/posthog/posthog/posthog/api/project.py: Warning [ProjectViewSet > ProjectBackwardCompatSerializer]: could not resolve field on model <class \'posthog.models.project.Project\'> with path "default_modifiers". This is likely a custom field that does some unknown magic. Maybe consider annotating the field/property? Defaulting to "string". (Exception: Project has no field named \'default_modifiers\')',
     '/home/runner/work/posthog/posthog/posthog/api/project.py: Warning [ProjectViewSet > ProjectBackwardCompatSerializer]: could not resolve field on model <class \'posthog.models.project.Project\'> with path "person_on_events_querying_enabled". This is likely a custom field that does some unknown magic. Maybe consider annotating the field/property? Defaulting to "string". (Exception: Project has no field named \'person_on_events_querying_enabled\')',
     '/home/runner/work/posthog/posthog/posthog/api/project.py: Warning [ProjectViewSet > ProjectBackwardCompatSerializer]: unable to resolve type hint for function "get_product_intents". Consider using a type hint or @extend_schema_field. Defaulting to string.',
     "/home/runner/work/posthog/posthog/posthog/api/property_definition.py: Error [PropertyDefinitionViewSet]: exception raised while getting serializer. Hint: Is get_serializer_class() returning None or is get_queryset() not working without a request? Ignoring the view for now. (Exception: 'AnonymousUser' object has no attribute 'organization')",
-    '/home/runner/work/posthog/posthog/posthog/api/property_definition.py: Warning [PropertyDefinitionViewSet]: could not derive type of path parameter "project_id" because model "posthog.models.property_definition.PropertyDefinition" contained no such field. Consider annotating parameter with @extend_schema. Defaulting to "string".',
     '/home/runner/work/posthog/posthog/posthog/api/proxy_record.py: Warning [ProxyRecordViewset]: could not derive type of path parameter "id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
     '/home/runner/work/posthog/posthog/posthog/api/proxy_record.py: Warning [ProxyRecordViewset]: could not derive type of path parameter "organization_id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:organization_id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
-    '/home/runner/work/posthog/posthog/posthog/api/query.py: Error [QueryViewSet]: unable to guess serializer. This is graceful fallback handling for APIViews. Consider using GenericAPIView as view base class, if view is under your control. Either way you may want to add a serializer_class (or method). Ignoring view for now.',
     '/home/runner/work/posthog/posthog/posthog/api/query.py: Warning [QueryViewSet]: could not derive type of path parameter "id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
     '/home/runner/work/posthog/posthog/posthog/api/query.py: Warning [QueryViewSet]: could not derive type of path parameter "project_id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:project_id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
     '/home/runner/work/posthog/posthog/posthog/api/session.py: Warning [SessionViewSet]: could not derive type of path parameter "project_id" because it is untyped and obtaining queryset from the viewset failed. Consider adding a type to the path (e.g. <int:project_id>) or annotating the parameter type with @extend_schema. Defaulting to "string".',
diff --git a/posthog/api/test/__snapshots__/test_cohort.ambr b/posthog/api/test/__snapshots__/test_cohort.ambr
index f1fe8c5d00333..2a4e7cdcc4d86 100644
--- a/posthog/api/test/__snapshots__/test_cohort.ambr
+++ b/posthog/api/test/__snapshots__/test_cohort.ambr
@@ -98,11 +98,14 @@
 # name: TestCohort.test_async_deletion_of_cohort.3
   '''
   /* user_id:0 celery:posthog.tasks.calculate_cohort.clear_stale_cohort */
-  SELECT count()
+  SELECT team_id,
+         count() AS stale_people_count
   FROM cohortpeople
-  WHERE team_id = 99999
+  WHERE team_id IN [1, 2, 3, 4, 5 /* ... */]
     AND cohort_id = 99999
     AND version < 1
+  GROUP BY team_id
+  HAVING stale_people_count > 0
   '''
 # ---
 # name: TestCohort.test_async_deletion_of_cohort.4
@@ -163,11 +166,14 @@
 # name: TestCohort.test_async_deletion_of_cohort.7
   '''
   /* user_id:0 celery:posthog.tasks.calculate_cohort.clear_stale_cohort */
-  SELECT count()
+  SELECT team_id,
+         count() AS stale_people_count
   FROM cohortpeople
-  WHERE team_id = 99999
+  WHERE team_id IN [1, 2, 3, 4, 5 /* ... */]
     AND cohort_id = 99999
     AND version < 2
+  GROUP BY team_id
+  HAVING stale_people_count > 0
   '''
 # ---
 # name: TestCohort.test_async_deletion_of_cohort.8
diff --git a/posthog/api/test/__snapshots__/test_decide.ambr b/posthog/api/test/__snapshots__/test_decide.ambr
index a1f1ebcced5c8..049ef77b360b5 100644
--- a/posthog/api/test/__snapshots__/test_decide.ambr
+++ b/posthog/api/test/__snapshots__/test_decide.ambr
@@ -265,6 +265,7 @@
          "posthog_hogfunction"."inputs",
          "posthog_hogfunction"."encrypted_inputs",
          "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
          "posthog_hogfunction"."masking",
          "posthog_hogfunction"."template_id",
          "posthog_team"."id",
@@ -337,14 +338,6 @@
   '''
 # ---
 # name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.18
-  '''
-  SELECT 1 AS "a"
-  FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
-  LIMIT 1
-  '''
-# ---
-# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.19
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -407,6 +400,18 @@
   LIMIT 21
   '''
 # ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.19
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
 # name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.2
   '''
   SELECT "posthog_team"."id",
@@ -418,63 +423,115 @@
 # ---
 # name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.20
   '''
-  SELECT "posthog_productintent"."id",
-         "posthog_productintent"."team_id",
-         "posthog_productintent"."created_at",
-         "posthog_productintent"."updated_at",
-         "posthog_productintent"."product_type",
-         "posthog_productintent"."onboarding_completed_at",
-         "posthog_productintent"."activated_at",
-         "posthog_productintent"."activation_last_checked_at"
-  FROM "posthog_productintent"
-  WHERE "posthog_productintent"."team_id" = 99999
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
 # name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.21
   '''
-  SELECT "posthog_productintent"."product_type",
-         "posthog_productintent"."created_at",
-         "posthog_productintent"."onboarding_completed_at",
-         "posthog_productintent"."updated_at"
-  FROM "posthog_productintent"
-  WHERE "posthog_productintent"."team_id" = 99999
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
 # name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.22
   '''
-  SELECT "posthog_user"."id",
-         "posthog_user"."password",
-         "posthog_user"."last_login",
-         "posthog_user"."first_name",
-         "posthog_user"."last_name",
-         "posthog_user"."is_staff",
-         "posthog_user"."date_joined",
-         "posthog_user"."uuid",
-         "posthog_user"."current_organization_id",
-         "posthog_user"."current_team_id",
-         "posthog_user"."email",
-         "posthog_user"."pending_email",
-         "posthog_user"."temporary_token",
-         "posthog_user"."distinct_id",
-         "posthog_user"."is_email_verified",
-         "posthog_user"."has_seen_product_intro_for",
-         "posthog_user"."strapi_id",
-         "posthog_user"."is_active",
-         "posthog_user"."theme_mode",
-         "posthog_user"."partial_notification_settings",
-         "posthog_user"."anonymize_data",
-         "posthog_user"."toolbar_mode",
-         "posthog_user"."hedgehog_config",
-         "posthog_user"."events_column_config",
-         "posthog_user"."email_opt_in"
-  FROM "posthog_user"
-  WHERE "posthog_user"."id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.23
-  '''
-  SELECT "posthog_featureflag"."id",
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
          "posthog_featureflag"."key",
          "posthog_featureflag"."name",
          "posthog_featureflag"."filters",
@@ -488,14 +545,46 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
   '''
 # ---
-# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.24
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.23
   '''
   SELECT "posthog_pluginconfig"."id",
          "posthog_pluginconfig"."web_token",
@@ -511,20 +600,125 @@
          AND "posthog_pluginconfig"."team_id" = 99999)
   '''
 # ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.24
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
 # name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.25
   '''
   SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
          "posthog_hogfunction"."updated_at",
-         "posthog_hogfunction"."type"
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
   WHERE ("posthog_hogfunction"."enabled"
          AND "posthog_hogfunction"."team_id" = 99999
-         AND "posthog_hogfunction"."transpiled" IS NOT NULL
          AND "posthog_hogfunction"."type" IN ('site_destination',
                                               'site_app'))
   '''
 # ---
-# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.3
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.26
+  '''
+  SELECT 1 AS "a"
+  FROM "posthog_grouptypemapping"
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
+  LIMIT 1
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.27
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -580,13 +774,6 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
@@ -594,16 +781,197 @@
   LIMIT 21
   '''
 # ---
-# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.4
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.28
   '''
-  SELECT "posthog_organizationmembership"."id",
-         "posthog_organizationmembership"."organization_id",
-         "posthog_organizationmembership"."user_id",
-         "posthog_organizationmembership"."level",
-         "posthog_organizationmembership"."joined_at",
-         "posthog_organizationmembership"."updated_at",
-         "posthog_organization"."id",
-         "posthog_organization"."name",
+  SELECT "posthog_productintent"."id",
+         "posthog_productintent"."team_id",
+         "posthog_productintent"."created_at",
+         "posthog_productintent"."updated_at",
+         "posthog_productintent"."product_type",
+         "posthog_productintent"."onboarding_completed_at",
+         "posthog_productintent"."activated_at",
+         "posthog_productintent"."activation_last_checked_at"
+  FROM "posthog_productintent"
+  WHERE "posthog_productintent"."team_id" = 99999
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.29
+  '''
+  SELECT "posthog_productintent"."product_type",
+         "posthog_productintent"."created_at",
+         "posthog_productintent"."onboarding_completed_at",
+         "posthog_productintent"."updated_at"
+  FROM "posthog_productintent"
+  WHERE "posthog_productintent"."team_id" = 99999
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.30
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.31
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.32
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.33
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_decide_doesnt_error_out_when_database_is_down.4
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
          "posthog_organization"."slug",
          "posthog_organization"."logo_media_id",
          "posthog_organization"."created_at",
@@ -804,6 +1172,7 @@
          "posthog_hogfunction"."inputs",
          "posthog_hogfunction"."encrypted_inputs",
          "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
          "posthog_hogfunction"."masking",
          "posthog_hogfunction"."template_id",
          "posthog_team"."id",
@@ -876,38 +1245,6 @@
   '''
 # ---
 # name: TestDecide.test_flag_with_behavioural_cohorts.1
-  '''
-  SELECT "posthog_user"."id",
-         "posthog_user"."password",
-         "posthog_user"."last_login",
-         "posthog_user"."first_name",
-         "posthog_user"."last_name",
-         "posthog_user"."is_staff",
-         "posthog_user"."date_joined",
-         "posthog_user"."uuid",
-         "posthog_user"."current_organization_id",
-         "posthog_user"."current_team_id",
-         "posthog_user"."email",
-         "posthog_user"."pending_email",
-         "posthog_user"."temporary_token",
-         "posthog_user"."distinct_id",
-         "posthog_user"."is_email_verified",
-         "posthog_user"."has_seen_product_intro_for",
-         "posthog_user"."strapi_id",
-         "posthog_user"."is_active",
-         "posthog_user"."theme_mode",
-         "posthog_user"."partial_notification_settings",
-         "posthog_user"."anonymize_data",
-         "posthog_user"."toolbar_mode",
-         "posthog_user"."hedgehog_config",
-         "posthog_user"."events_column_config",
-         "posthog_user"."email_opt_in"
-  FROM "posthog_user"
-  WHERE "posthog_user"."id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestDecide.test_flag_with_behavioural_cohorts.2
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -963,13 +1300,6 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
@@ -977,7 +1307,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestDecide.test_flag_with_behavioural_cohorts.3
+# name: TestDecide.test_flag_with_behavioural_cohorts.10
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -1000,111 +1330,9 @@
          AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
-# name: TestDecide.test_flag_with_behavioural_cohorts.4
-  '''
-  SELECT "posthog_cohort"."id",
-         "posthog_cohort"."name",
-         "posthog_cohort"."description",
-         "posthog_cohort"."team_id",
-         "posthog_cohort"."deleted",
-         "posthog_cohort"."filters",
-         "posthog_cohort"."query",
-         "posthog_cohort"."version",
-         "posthog_cohort"."pending_version",
-         "posthog_cohort"."count",
-         "posthog_cohort"."created_by_id",
-         "posthog_cohort"."created_at",
-         "posthog_cohort"."is_calculating",
-         "posthog_cohort"."last_calculation",
-         "posthog_cohort"."errors_calculating",
-         "posthog_cohort"."last_error_at",
-         "posthog_cohort"."is_static",
-         "posthog_cohort"."groups"
-  FROM "posthog_cohort"
-  WHERE (NOT "posthog_cohort"."deleted"
-         AND "posthog_cohort"."team_id" = 99999)
-  '''
-# ---
-# name: TestDecide.test_flag_with_behavioural_cohorts.5
+# name: TestDecide.test_flag_with_behavioural_cohorts.11
   '''
-  SELECT "posthog_group"."id",
-         "posthog_group"."team_id",
-         "posthog_group"."group_key",
-         "posthog_group"."group_type_index",
-         "posthog_group"."group_properties",
-         "posthog_group"."created_at",
-         "posthog_group"."properties_last_updated_at",
-         "posthog_group"."properties_last_operation",
-         "posthog_group"."version"
-  FROM "posthog_group"
-  WHERE "posthog_group"."team_id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestDecide.test_flag_with_behavioural_cohorts.6
-  '''
-  SELECT "posthog_cohort"."id",
-         "posthog_cohort"."name",
-         "posthog_cohort"."description",
-         "posthog_cohort"."team_id",
-         "posthog_cohort"."deleted",
-         "posthog_cohort"."filters",
-         "posthog_cohort"."query",
-         "posthog_cohort"."version",
-         "posthog_cohort"."pending_version",
-         "posthog_cohort"."count",
-         "posthog_cohort"."created_by_id",
-         "posthog_cohort"."created_at",
-         "posthog_cohort"."is_calculating",
-         "posthog_cohort"."last_calculation",
-         "posthog_cohort"."errors_calculating",
-         "posthog_cohort"."last_error_at",
-         "posthog_cohort"."is_static",
-         "posthog_cohort"."groups"
-  FROM "posthog_cohort"
-  WHERE (NOT "posthog_cohort"."deleted"
-         AND "posthog_cohort"."team_id" = 99999)
-  '''
-# ---
-# name: TestDecide.test_flag_with_behavioural_cohorts.7
-  '''
-  SELECT "posthog_group"."id",
-         "posthog_group"."team_id",
-         "posthog_group"."group_key",
-         "posthog_group"."group_type_index",
-         "posthog_group"."group_properties",
-         "posthog_group"."created_at",
-         "posthog_group"."properties_last_updated_at",
-         "posthog_group"."properties_last_operation",
-         "posthog_group"."version"
-  FROM "posthog_group"
-  WHERE "posthog_group"."team_id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestDecide.test_flag_with_regular_cohorts
-  '''
-  SELECT "posthog_hogfunction"."id",
-         "posthog_hogfunction"."team_id",
-         "posthog_hogfunction"."name",
-         "posthog_hogfunction"."description",
-         "posthog_hogfunction"."created_at",
-         "posthog_hogfunction"."created_by_id",
-         "posthog_hogfunction"."deleted",
-         "posthog_hogfunction"."updated_at",
-         "posthog_hogfunction"."enabled",
-         "posthog_hogfunction"."type",
-         "posthog_hogfunction"."icon_url",
-         "posthog_hogfunction"."hog",
-         "posthog_hogfunction"."bytecode",
-         "posthog_hogfunction"."transpiled",
-         "posthog_hogfunction"."inputs_schema",
-         "posthog_hogfunction"."inputs",
-         "posthog_hogfunction"."encrypted_inputs",
-         "posthog_hogfunction"."filters",
-         "posthog_hogfunction"."masking",
-         "posthog_hogfunction"."template_id",
-         "posthog_team"."id",
+  SELECT "posthog_team"."id",
          "posthog_team"."uuid",
          "posthog_team"."organization_id",
          "posthog_team"."project_id",
@@ -1158,54 +1386,26 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_hogfunction"
-  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
-  WHERE ("posthog_hogfunction"."team_id" = 99999
-         AND "posthog_hogfunction"."filters" @> '{"filter_test_accounts": true}'::jsonb)
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestDecide.test_flag_with_regular_cohorts.1
+# name: TestDecide.test_flag_with_behavioural_cohorts.12
   '''
-  SELECT "posthog_user"."id",
-         "posthog_user"."password",
-         "posthog_user"."last_login",
-         "posthog_user"."first_name",
-         "posthog_user"."last_name",
-         "posthog_user"."is_staff",
-         "posthog_user"."date_joined",
-         "posthog_user"."uuid",
-         "posthog_user"."current_organization_id",
-         "posthog_user"."current_team_id",
-         "posthog_user"."email",
-         "posthog_user"."pending_email",
-         "posthog_user"."temporary_token",
-         "posthog_user"."distinct_id",
-         "posthog_user"."is_email_verified",
-         "posthog_user"."has_seen_product_intro_for",
-         "posthog_user"."strapi_id",
-         "posthog_user"."is_active",
-         "posthog_user"."theme_mode",
-         "posthog_user"."partial_notification_settings",
-         "posthog_user"."anonymize_data",
-         "posthog_user"."toolbar_mode",
-         "posthog_user"."hedgehog_config",
-         "posthog_user"."events_column_config",
-         "posthog_user"."email_opt_in"
-  FROM "posthog_user"
-  WHERE "posthog_user"."id" = 99999
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
   LIMIT 21
   '''
 # ---
-# name: TestDecide.test_flag_with_regular_cohorts.2
+# name: TestDecide.test_flag_with_behavioural_cohorts.13
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -1275,9 +1475,47 @@
   LIMIT 21
   '''
 # ---
-# name: TestDecide.test_flag_with_regular_cohorts.3
+# name: TestDecide.test_flag_with_behavioural_cohorts.14
   '''
-  SELECT "posthog_featureflag"."id",
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.15
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
          "posthog_featureflag"."key",
          "posthog_featureflag"."name",
          "posthog_featureflag"."filters",
@@ -1291,90 +1529,85 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
-  '''
-# ---
-# name: TestDecide.test_flag_with_regular_cohorts.4
-  '''
-  SELECT "posthog_cohort"."id",
-         "posthog_cohort"."name",
-         "posthog_cohort"."description",
-         "posthog_cohort"."team_id",
-         "posthog_cohort"."deleted",
-         "posthog_cohort"."filters",
-         "posthog_cohort"."query",
-         "posthog_cohort"."version",
-         "posthog_cohort"."pending_version",
-         "posthog_cohort"."count",
-         "posthog_cohort"."created_by_id",
-         "posthog_cohort"."created_at",
-         "posthog_cohort"."is_calculating",
-         "posthog_cohort"."last_calculation",
-         "posthog_cohort"."errors_calculating",
-         "posthog_cohort"."last_error_at",
-         "posthog_cohort"."is_static",
-         "posthog_cohort"."groups"
-  FROM "posthog_cohort"
-  WHERE (NOT "posthog_cohort"."deleted"
-         AND "posthog_cohort"."team_id" = 99999)
-  '''
-# ---
-# name: TestDecide.test_flag_with_regular_cohorts.5
-  '''
-  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
-          AND "posthog_person"."properties" ? '$some_prop_1'
-          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
-  FROM "posthog_person"
-  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = 'example_id_1'
-         AND "posthog_persondistinctid"."team_id" = 99999
-         AND "posthog_person"."team_id" = 99999)
-  '''
-# ---
-# name: TestDecide.test_flag_with_regular_cohorts.6
-  '''
-  SELECT "posthog_cohort"."id",
-         "posthog_cohort"."name",
-         "posthog_cohort"."description",
-         "posthog_cohort"."team_id",
-         "posthog_cohort"."deleted",
-         "posthog_cohort"."filters",
-         "posthog_cohort"."query",
-         "posthog_cohort"."version",
-         "posthog_cohort"."pending_version",
-         "posthog_cohort"."count",
-         "posthog_cohort"."created_by_id",
-         "posthog_cohort"."created_at",
-         "posthog_cohort"."is_calculating",
-         "posthog_cohort"."last_calculation",
-         "posthog_cohort"."errors_calculating",
-         "posthog_cohort"."last_error_at",
-         "posthog_cohort"."is_static",
-         "posthog_cohort"."groups"
-  FROM "posthog_cohort"
-  WHERE (NOT "posthog_cohort"."deleted"
-         AND "posthog_cohort"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
   '''
 # ---
-# name: TestDecide.test_flag_with_regular_cohorts.7
+# name: TestDecide.test_flag_with_behavioural_cohorts.16
   '''
-  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
-          AND "posthog_person"."properties" ? '$some_prop_1'
-          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
-  FROM "posthog_person"
-  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
-         AND "posthog_persondistinctid"."team_id" = 99999
-         AND "posthog_person"."team_id" = 99999)
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
   '''
 # ---
-# name: TestDecide.test_web_app_queries
+# name: TestDecide.test_flag_with_behavioural_cohorts.17
   '''
-  SELECT "posthog_team"."id",
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
          "posthog_team"."uuid",
          "posthog_team"."organization_id",
          "posthog_team"."project_id",
@@ -1428,21 +1661,7406 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."api_token" = 'token123'
-  LIMIT 21
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
-# name: TestDecide.test_web_app_queries.1
+# name: TestDecide.test_flag_with_behavioural_cohorts.18
   '''
-  SELECT "posthog_featureflag"."id",
-         "posthog_featureflag"."key",
-         "posthog_featureflag"."name",
-         "posthog_featureflag"."filters",
-         "posthog_featureflag"."rollout_percentage",
-         "posthog_featureflag"."team_id",
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.19
+  '''
+  SELECT "posthog_group"."id",
+         "posthog_group"."team_id",
+         "posthog_group"."group_key",
+         "posthog_group"."group_type_index",
+         "posthog_group"."group_properties",
+         "posthog_group"."created_at",
+         "posthog_group"."properties_last_updated_at",
+         "posthog_group"."properties_last_operation",
+         "posthog_group"."version"
+  FROM "posthog_group"
+  WHERE "posthog_group"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.2
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.20
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.21
+  '''
+  SELECT "posthog_group"."id",
+         "posthog_group"."team_id",
+         "posthog_group"."group_key",
+         "posthog_group"."group_type_index",
+         "posthog_group"."group_properties",
+         "posthog_group"."created_at",
+         "posthog_group"."properties_last_updated_at",
+         "posthog_group"."properties_last_operation",
+         "posthog_group"."version"
+  FROM "posthog_group"
+  WHERE "posthog_group"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.22
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.23
+  '''
+  SELECT "posthog_group"."id",
+         "posthog_group"."team_id",
+         "posthog_group"."group_key",
+         "posthog_group"."group_type_index",
+         "posthog_group"."group_properties",
+         "posthog_group"."created_at",
+         "posthog_group"."properties_last_updated_at",
+         "posthog_group"."properties_last_operation",
+         "posthog_group"."version"
+  FROM "posthog_group"
+  WHERE "posthog_group"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.4
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.5
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.6
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.7
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.8
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_behavioural_cohorts.9
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."filters" @> '{"filter_test_accounts": true}'::jsonb)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.1
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.10
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.11
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.12
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.13
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.14
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.15
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.16
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.17
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.18
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.19
+  '''
+  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
+          AND "posthog_person"."properties" ? '$some_prop_1'
+          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'example_id_1'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.2
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.20
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.21
+  '''
+  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
+          AND "posthog_person"."properties" ? '$some_prop_1'
+          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.22
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.23
+  '''
+  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
+          AND "posthog_person"."properties" ? '$some_prop_1'
+          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.4
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.5
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.6
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.7
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.8
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_flag_with_regular_cohorts.9
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."api_token" = 'token123'
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.1
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.10
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.11
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.12
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.13
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.14
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.15
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.16
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.17
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.18
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.19
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.2
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.20
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.21
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.22
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.23
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.3
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."filters" @> '{"filter_test_accounts": true}'::jsonb)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.4
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.5
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.6
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.7
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.8
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecide.test_web_app_queries.9
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.1
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE "posthog_organizationmembership"."user_id" = 99999
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.10
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE "posthog_organizationmembership"."user_id" = 99999
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.11
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."organization_id",
+         "posthog_team"."access_control"
+  FROM "posthog_team"
+  WHERE "posthog_team"."organization_id" IN ('00000000-0000-0000-0000-000000000000'::uuid)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.12
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.13
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE "posthog_organizationmembership"."user_id" = 99999
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.14
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE "posthog_organizationmembership"."user_id" = 99999
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.15
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."organization_id",
+         "posthog_team"."access_control"
+  FROM "posthog_team"
+  WHERE "posthog_team"."organization_id" IN ('00000000-0000-0000-0000-000000000000'::uuid)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.16
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.17
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."filters" @> '{"filter_test_accounts": true}'::jsonb)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.18
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.19
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.2
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."organization_id",
+         "posthog_team"."access_control"
+  FROM "posthog_team"
+  WHERE "posthog_team"."organization_id" IN ('00000000-0000-0000-0000-000000000000'::uuid)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.20
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.21
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.22
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.23
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.24
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.25
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.26
+  '''
+  SELECT 1 AS "a"
+  FROM "posthog_grouptypemapping"
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
+  LIMIT 1
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.27
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.28
+  '''
+  SELECT "posthog_productintent"."id",
+         "posthog_productintent"."team_id",
+         "posthog_productintent"."created_at",
+         "posthog_productintent"."updated_at",
+         "posthog_productintent"."product_type",
+         "posthog_productintent"."onboarding_completed_at",
+         "posthog_productintent"."activated_at",
+         "posthog_productintent"."activation_last_checked_at"
+  FROM "posthog_productintent"
+  WHERE "posthog_productintent"."team_id" = 99999
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.29
+  '''
+  SELECT "posthog_productintent"."product_type",
+         "posthog_productintent"."created_at",
+         "posthog_productintent"."onboarding_completed_at",
+         "posthog_productintent"."updated_at"
+  FROM "posthog_productintent"
+  WHERE "posthog_productintent"."team_id" = 99999
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.30
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.31
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.32
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.33
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.34
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.35
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.36
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.37
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.38
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.39
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.4
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.40
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.41
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.42
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.43
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginconfig"."web_token",
+         "posthog_pluginsourcefile"."updated_at",
+         "posthog_plugin"."updated_at",
+         "posthog_pluginconfig"."updated_at"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.44
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.45
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.46
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.47
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id"
+  FROM "posthog_hogfunction"
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.48
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id"
+  FROM "posthog_hogfunction"
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.5
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE "posthog_organizationmembership"."user_id" = 99999
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.6
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."organization_id",
+         "posthog_team"."access_control"
+  FROM "posthog_team"
+  WHERE "posthog_team"."organization_id" IN ('00000000-0000-0000-0000-000000000000'::uuid)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.7
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.8
+  '''
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_decide_doesnt_error_out_when_database_is_down.9
+  '''
+  SELECT "ee_accesscontrol"."id",
+         "ee_accesscontrol"."team_id",
+         "ee_accesscontrol"."access_level",
+         "ee_accesscontrol"."resource",
+         "ee_accesscontrol"."resource_id",
+         "ee_accesscontrol"."organization_member_id",
+         "ee_accesscontrol"."role_id",
+         "ee_accesscontrol"."created_by_id",
+         "ee_accesscontrol"."created_at",
+         "ee_accesscontrol"."updated_at"
+  FROM "ee_accesscontrol"
+  LEFT OUTER JOIN "posthog_organizationmembership" ON ("ee_accesscontrol"."organization_member_id" = "posthog_organizationmembership"."id")
+  INNER JOIN "posthog_team" ON ("ee_accesscontrol"."team_id" = "posthog_team"."id")
+  WHERE (("ee_accesscontrol"."organization_member_id" IS NULL
+          AND "ee_accesscontrol"."resource" = 'project'
+          AND "ee_accesscontrol"."resource_id" = '99999'
+          AND "ee_accesscontrol"."role_id" IS NULL
+          AND "ee_accesscontrol"."team_id" = 99999)
+         OR ("posthog_organizationmembership"."user_id" = 99999
+             AND "ee_accesscontrol"."resource" = 'project'
+             AND "ee_accesscontrol"."resource_id" = '99999'
+             AND "ee_accesscontrol"."role_id" IS NULL
+             AND "ee_accesscontrol"."team_id" = 99999)
+         OR ("ee_accesscontrol"."organization_member_id" IS NULL
+             AND "ee_accesscontrol"."resource" = 'project'
+             AND "ee_accesscontrol"."resource_id" IS NULL
+             AND "ee_accesscontrol"."role_id" IS NULL
+             AND "ee_accesscontrol"."team_id" = 99999)
+         OR ("posthog_organizationmembership"."user_id" = 99999
+             AND "ee_accesscontrol"."resource" = 'project'
+             AND "ee_accesscontrol"."resource_id" IS NULL
+             AND "ee_accesscontrol"."role_id" IS NULL
+             AND "ee_accesscontrol"."team_id" = 99999)
+         OR ("ee_accesscontrol"."organization_member_id" IS NULL
+             AND "ee_accesscontrol"."resource" = 'project'
+             AND "ee_accesscontrol"."resource_id" IS NOT NULL
+             AND "ee_accesscontrol"."role_id" IS NULL
+             AND "posthog_team"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid)
+         OR ("posthog_organizationmembership"."user_id" = 99999
+             AND "ee_accesscontrol"."resource" = 'project'
+             AND "ee_accesscontrol"."resource_id" IS NOT NULL
+             AND "ee_accesscontrol"."role_id" IS NULL
+             AND "posthog_team"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."filters" @> '{"filter_test_accounts": true}'::jsonb)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.1
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.10
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.11
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.12
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.13
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.14
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.15
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.16
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.17
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.18
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.19
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.2
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.20
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.21
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.22
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.23
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.24
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.25
+  '''
+  SELECT "posthog_group"."id",
+         "posthog_group"."team_id",
+         "posthog_group"."group_key",
+         "posthog_group"."group_type_index",
+         "posthog_group"."group_properties",
+         "posthog_group"."created_at",
+         "posthog_group"."properties_last_updated_at",
+         "posthog_group"."properties_last_operation",
+         "posthog_group"."version"
+  FROM "posthog_group"
+  WHERE "posthog_group"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.26
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.27
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.28
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.29
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.30
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.31
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.32
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.33
+  '''
+  SELECT "posthog_group"."id",
+         "posthog_group"."team_id",
+         "posthog_group"."group_key",
+         "posthog_group"."group_type_index",
+         "posthog_group"."group_properties",
+         "posthog_group"."created_at",
+         "posthog_group"."properties_last_updated_at",
+         "posthog_group"."properties_last_operation",
+         "posthog_group"."version"
+  FROM "posthog_group"
+  WHERE "posthog_group"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.34
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id"
+  FROM "posthog_hogfunction"
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.35
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id"
+  FROM "posthog_hogfunction"
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.36
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.37
+  '''
+  SELECT "posthog_group"."id",
+         "posthog_group"."team_id",
+         "posthog_group"."group_key",
+         "posthog_group"."group_type_index",
+         "posthog_group"."group_properties",
+         "posthog_group"."created_at",
+         "posthog_group"."properties_last_updated_at",
+         "posthog_group"."properties_last_operation",
+         "posthog_group"."version"
+  FROM "posthog_group"
+  WHERE "posthog_group"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.4
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.5
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.6
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.7
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.8
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_behavioural_cohorts.9
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."filters" @> '{"filter_test_accounts": true}'::jsonb)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.1
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.10
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.11
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.12
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.13
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.14
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.15
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.16
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.17
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.18
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.19
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.2
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.20
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.21
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.22
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.23
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.24
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.25
+  '''
+  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
+          AND "posthog_person"."properties" ? '$some_prop_1'
+          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'example_id_1'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.26
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.27
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.28
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.29
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.30
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.31
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.32
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.33
+  '''
+  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
+          AND "posthog_person"."properties" ? '$some_prop_1'
+          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.34
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id"
+  FROM "posthog_hogfunction"
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  LIMIT 21
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.35
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id"
+  FROM "posthog_hogfunction"
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.36
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  WHERE (NOT "posthog_cohort"."deleted"
+         AND "posthog_cohort"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.37
+  '''
+  SELECT (("posthog_person"."properties" -> '$some_prop_1') = '"something_1"'::jsonb
+          AND "posthog_person"."properties" ? '$some_prop_1'
+          AND NOT (("posthog_person"."properties" -> '$some_prop_1') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.4
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.5
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
          "posthog_featureflag"."created_by_id",
          "posthog_featureflag"."created_at",
          "posthog_featureflag"."deleted",
@@ -1451,20 +9069,52 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
   '''
 # ---
-# name: TestDecide.test_web_app_queries.2
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.6
   '''
   SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
          "posthog_pluginconfig"."web_token",
-         "posthog_pluginsourcefile"."updated_at",
-         "posthog_plugin"."updated_at",
-         "posthog_pluginconfig"."updated_at"
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
   FROM "posthog_pluginconfig"
   INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
   INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
@@ -1474,7 +9124,7 @@
          AND "posthog_pluginconfig"."team_id" = 99999)
   '''
 # ---
-# name: TestDecide.test_web_app_queries.3
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.7
   '''
   SELECT "posthog_hogfunction"."id",
          "posthog_hogfunction"."team_id",
@@ -1494,6 +9144,7 @@
          "posthog_hogfunction"."inputs",
          "posthog_hogfunction"."encrypted_inputs",
          "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
          "posthog_hogfunction"."masking",
          "posthog_hogfunction"."template_id",
          "posthog_team"."id",
@@ -1561,52 +9212,111 @@
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_hogfunction"
   INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
-  WHERE ("posthog_hogfunction"."team_id" = 99999
-         AND "posthog_hogfunction"."filters" @> '{"filter_test_accounts": true}'::jsonb)
-  '''
-# ---
-# name: TestDecide.test_web_app_queries.4
-  '''
-  SELECT "posthog_pluginconfig"."id",
-         "posthog_pluginconfig"."web_token",
-         "posthog_pluginsourcefile"."updated_at",
-         "posthog_plugin"."updated_at",
-         "posthog_pluginconfig"."updated_at"
-  FROM "posthog_pluginconfig"
-  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
-  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
-  WHERE ("posthog_pluginconfig"."enabled"
-         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
-         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
-         AND "posthog_pluginconfig"."team_id" = 99999)
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
-# name: TestDecide.test_web_app_queries.5
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.8
   '''
-  SELECT "posthog_pluginconfig"."id",
-         "posthog_pluginconfig"."web_token",
-         "posthog_pluginsourcefile"."updated_at",
-         "posthog_plugin"."updated_at",
-         "posthog_pluginconfig"."updated_at"
-  FROM "posthog_pluginconfig"
-  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
-  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
-  WHERE ("posthog_pluginconfig"."enabled"
-         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
-         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
-         AND "posthog_pluginconfig"."team_id" = 99999)
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestDecide.test_web_app_queries.6
+# name: TestDecideRemoteConfig.test_flag_with_regular_cohorts.9
   '''
-  SELECT "posthog_hogfunction"."id",
-         "posthog_hogfunction"."updated_at",
-         "posthog_hogfunction"."type"
-  FROM "posthog_hogfunction"
-  WHERE ("posthog_hogfunction"."enabled"
-         AND "posthog_hogfunction"."team_id" = 99999
-         AND "posthog_hogfunction"."transpiled" IS NOT NULL
-         AND "posthog_hogfunction"."type" IN ('site_destination',
-                                              'site_app'))
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
diff --git a/posthog/api/test/__snapshots__/test_early_access_feature.ambr b/posthog/api/test/__snapshots__/test_early_access_feature.ambr
index 7e33fb1c9d19e..c7820616d0cfd 100644
--- a/posthog/api/test/__snapshots__/test_early_access_feature.ambr
+++ b/posthog/api/test/__snapshots__/test_early_access_feature.ambr
@@ -92,9 +92,192 @@
          AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
-# name: TestPreviewList.test_early_access_features.2
+# name: TestPreviewList.test_early_access_features.10
   '''
-  SELECT "posthog_featureflag"."id",
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.11
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.12
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.13
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.14
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
          "posthog_featureflag"."key",
          "posthog_featureflag"."name",
          "posthog_featureflag"."filters",
@@ -108,14 +291,156 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
   '''
 # ---
-# name: TestPreviewList.test_early_access_features.3
+# name: TestPreviewList.test_early_access_features.15
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.16
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.17
   '''
   SELECT "posthog_user"."id",
          "posthog_user"."password",
@@ -147,7 +472,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestPreviewList.test_early_access_features.4
+# name: TestPreviewList.test_early_access_features.18
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -210,7 +535,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestPreviewList.test_early_access_features.5
+# name: TestPreviewList.test_early_access_features.19
   '''
   SELECT "posthog_earlyaccessfeature"."id",
          "posthog_earlyaccessfeature"."team_id",
@@ -236,8 +561,1612 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_earlyaccessfeature"
+  INNER JOIN "posthog_team" ON ("posthog_earlyaccessfeature"."team_id" = "posthog_team"."id")
   LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_earlyaccessfeature"."feature_flag_id" = "posthog_featureflag"."id")
   WHERE ("posthog_earlyaccessfeature"."stage" = 'beta'
-         AND "posthog_earlyaccessfeature"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.2
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.20
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."api_token" = 'token123'
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.21
+  '''
+  SELECT "posthog_earlyaccessfeature"."id",
+         "posthog_earlyaccessfeature"."team_id",
+         "posthog_earlyaccessfeature"."feature_flag_id",
+         "posthog_earlyaccessfeature"."name",
+         "posthog_earlyaccessfeature"."description",
+         "posthog_earlyaccessfeature"."stage",
+         "posthog_earlyaccessfeature"."documentation_url",
+         "posthog_earlyaccessfeature"."created_at",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_earlyaccessfeature"
+  INNER JOIN "posthog_team" ON ("posthog_earlyaccessfeature"."team_id" = "posthog_team"."id")
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_earlyaccessfeature"."feature_flag_id" = "posthog_featureflag"."id")
+  WHERE ("posthog_earlyaccessfeature"."stage" = 'beta'
+         AND "posthog_team"."project_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.3
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.4
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.5
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.6
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.7
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.8
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features.9
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.1
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."api_token" = 'token123'
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.10
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.11
+  '''
+  SELECT "posthog_earlyaccessfeature"."id",
+         "posthog_earlyaccessfeature"."team_id",
+         "posthog_earlyaccessfeature"."feature_flag_id",
+         "posthog_earlyaccessfeature"."name",
+         "posthog_earlyaccessfeature"."description",
+         "posthog_earlyaccessfeature"."stage",
+         "posthog_earlyaccessfeature"."documentation_url",
+         "posthog_earlyaccessfeature"."created_at",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_earlyaccessfeature"
+  INNER JOIN "posthog_team" ON ("posthog_earlyaccessfeature"."team_id" = "posthog_team"."id")
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_earlyaccessfeature"."feature_flag_id" = "posthog_featureflag"."id")
+  WHERE ("posthog_earlyaccessfeature"."stage" = 'beta'
+         AND "posthog_team"."project_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.12
+  '''
+  SELECT "posthog_earlyaccessfeature"."id",
+         "posthog_earlyaccessfeature"."team_id",
+         "posthog_earlyaccessfeature"."feature_flag_id",
+         "posthog_earlyaccessfeature"."name",
+         "posthog_earlyaccessfeature"."description",
+         "posthog_earlyaccessfeature"."stage",
+         "posthog_earlyaccessfeature"."documentation_url",
+         "posthog_earlyaccessfeature"."created_at",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_earlyaccessfeature"
+  INNER JOIN "posthog_team" ON ("posthog_earlyaccessfeature"."team_id" = "posthog_team"."id")
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_earlyaccessfeature"."feature_flag_id" = "posthog_featureflag"."id")
+  WHERE ("posthog_earlyaccessfeature"."stage" = 'beta'
+         AND "posthog_team"."project_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.2
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.4
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.5
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.6
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.7
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.8
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_cached_team.9
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.1
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.10
+  '''
+  SELECT "posthog_earlyaccessfeature"."id",
+         "posthog_earlyaccessfeature"."team_id",
+         "posthog_earlyaccessfeature"."feature_flag_id",
+         "posthog_earlyaccessfeature"."name",
+         "posthog_earlyaccessfeature"."description",
+         "posthog_earlyaccessfeature"."stage",
+         "posthog_earlyaccessfeature"."documentation_url",
+         "posthog_earlyaccessfeature"."created_at",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_earlyaccessfeature"
+  INNER JOIN "posthog_team" ON ("posthog_earlyaccessfeature"."team_id" = "posthog_team"."id")
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_earlyaccessfeature"."feature_flag_id" = "posthog_featureflag"."id")
+  WHERE ("posthog_earlyaccessfeature"."stage" = 'beta'
+         AND "posthog_team"."project_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.11
+  '''
+  SELECT "posthog_earlyaccessfeature"."id",
+         "posthog_earlyaccessfeature"."team_id",
+         "posthog_earlyaccessfeature"."feature_flag_id",
+         "posthog_earlyaccessfeature"."name",
+         "posthog_earlyaccessfeature"."description",
+         "posthog_earlyaccessfeature"."stage",
+         "posthog_earlyaccessfeature"."documentation_url",
+         "posthog_earlyaccessfeature"."created_at",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_earlyaccessfeature"
+  INNER JOIN "posthog_team" ON ("posthog_earlyaccessfeature"."team_id" = "posthog_team"."id")
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_earlyaccessfeature"."feature_flag_id" = "posthog_featureflag"."id")
+  WHERE ("posthog_earlyaccessfeature"."stage" = 'beta'
+         AND "posthog_team"."project_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.2
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.3
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.4
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.5
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.6
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.7
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.8
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestPreviewList.test_early_access_features_with_pre_env_cached_team.9
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
   '''
 # ---
diff --git a/posthog/api/test/__snapshots__/test_event.ambr b/posthog/api/test/__snapshots__/test_event.ambr
index c5e560c8bdba2..6ad9d56dc606c 100644
--- a/posthog/api/test/__snapshots__/test_event.ambr
+++ b/posthog/api/test/__snapshots__/test_event.ambr
@@ -1,14 +1,14 @@
 # serializer version: 1
 # name: TestEvents.test_event_property_values
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
+  /* user_id:0 request:_snapshot_ */
+  SELECT DISTINCT replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '')
   FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  WHERE team_id = 99999
+    AND JSONHas(properties, 'random_prop')
+    AND timestamp >= '2020-01-13 00:00:00'
+    AND timestamp <= '2020-01-20 23:59:59'
+  LIMIT 10
   '''
 # ---
 # name: TestEvents.test_event_property_values.1
@@ -20,6 +20,8 @@
     AND JSONHas(properties, 'random_prop')
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
+    AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%qw%'
+  order by length(replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', ''))
   LIMIT 10
   '''
 # ---
@@ -32,7 +34,7 @@
     AND JSONHas(properties, 'random_prop')
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%qw%'
+    AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%QW%'
   order by length(replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', ''))
   LIMIT 10
   '''
@@ -46,7 +48,7 @@
     AND JSONHas(properties, 'random_prop')
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%QW%'
+    AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%6%'
   order by length(replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', ''))
   LIMIT 10
   '''
@@ -60,6 +62,7 @@
     AND JSONHas(properties, 'random_prop')
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
+    AND (event = 'random event')
     AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%6%'
   order by length(replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', ''))
   LIMIT 10
@@ -74,7 +77,8 @@
     AND JSONHas(properties, 'random_prop')
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND (event = 'random event')
+    AND (event = 'foo'
+         OR event = 'random event')
     AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%6%'
   order by length(replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', ''))
   LIMIT 10
@@ -89,9 +93,8 @@
     AND JSONHas(properties, 'random_prop')
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND (event = 'foo'
-         OR event = 'random event')
-    AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%6%'
+    AND (event = '404_i_dont_exist')
+    AND replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', '') ILIKE '%qw%'
   order by length(replaceRegexpAll(JSONExtractRaw(properties, 'random_prop'), '^"|"$', ''))
   LIMIT 10
   '''
@@ -113,14 +116,14 @@
 # ---
 # name: TestEvents.test_event_property_values_materialized
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
+  /* user_id:0 request:_snapshot_ */
+  SELECT DISTINCT "mat_random_prop"
   FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  WHERE team_id = 99999
+    AND notEmpty("mat_random_prop")
+    AND timestamp >= '2020-01-13 00:00:00'
+    AND timestamp <= '2020-01-20 23:59:59'
+  LIMIT 10
   '''
 # ---
 # name: TestEvents.test_event_property_values_materialized.1
@@ -132,6 +135,8 @@
     AND notEmpty("mat_random_prop")
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
+    AND "mat_random_prop" ILIKE '%qw%'
+  order by length("mat_random_prop")
   LIMIT 10
   '''
 # ---
@@ -144,7 +149,7 @@
     AND notEmpty("mat_random_prop")
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND "mat_random_prop" ILIKE '%qw%'
+    AND "mat_random_prop" ILIKE '%QW%'
   order by length("mat_random_prop")
   LIMIT 10
   '''
@@ -158,7 +163,7 @@
     AND notEmpty("mat_random_prop")
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND "mat_random_prop" ILIKE '%QW%'
+    AND "mat_random_prop" ILIKE '%6%'
   order by length("mat_random_prop")
   LIMIT 10
   '''
@@ -172,6 +177,7 @@
     AND notEmpty("mat_random_prop")
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
+    AND (event = 'random event')
     AND "mat_random_prop" ILIKE '%6%'
   order by length("mat_random_prop")
   LIMIT 10
@@ -186,7 +192,8 @@
     AND notEmpty("mat_random_prop")
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND (event = 'random event')
+    AND (event = 'foo'
+         OR event = 'random event')
     AND "mat_random_prop" ILIKE '%6%'
   order by length("mat_random_prop")
   LIMIT 10
@@ -201,9 +208,8 @@
     AND notEmpty("mat_random_prop")
     AND timestamp >= '2020-01-13 00:00:00'
     AND timestamp <= '2020-01-20 23:59:59'
-    AND (event = 'foo'
-         OR event = 'random event')
-    AND "mat_random_prop" ILIKE '%6%'
+    AND (event = '404_i_dont_exist')
+    AND "mat_random_prop" ILIKE '%qw%'
   order by length("mat_random_prop")
   LIMIT 10
   '''
diff --git a/posthog/api/test/__snapshots__/test_feature_flag.ambr b/posthog/api/test/__snapshots__/test_feature_flag.ambr
index b51af7a796f7d..a00efc8ba764b 100644
--- a/posthog/api/test/__snapshots__/test_feature_flag.ambr
+++ b/posthog/api/test/__snapshots__/test_feature_flag.ambr
@@ -336,6 +336,15 @@
   '''
 # ---
 # name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."project_id"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.1
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -353,12 +362,13 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."key" = 'some-feature2'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.1
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.2
   '''
   SELECT "posthog_cohort"."id",
          "posthog_cohort"."name",
@@ -379,12 +389,13 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE ("posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.2
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.3
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -405,7 +416,7 @@
   LIMIT 2
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.3
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.4
   '''
   SELECT "posthog_persondistinctid"."id",
          "posthog_persondistinctid"."team_id",
@@ -425,7 +436,7 @@
                                                         5 /* ... */))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.4
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.5
   '''
   SELECT "posthog_person"."uuid"
   FROM "posthog_person"
@@ -440,76 +451,6 @@
                      LIMIT 1)))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.5
-  '''
-  SELECT "posthog_team"."id",
-         "posthog_team"."uuid",
-         "posthog_team"."organization_id",
-         "posthog_team"."project_id",
-         "posthog_team"."api_token",
-         "posthog_team"."app_urls",
-         "posthog_team"."name",
-         "posthog_team"."slack_incoming_webhook",
-         "posthog_team"."created_at",
-         "posthog_team"."updated_at",
-         "posthog_team"."anonymize_ips",
-         "posthog_team"."completed_snippet_onboarding",
-         "posthog_team"."has_completed_onboarding_for",
-         "posthog_team"."ingested_event",
-         "posthog_team"."autocapture_opt_out",
-         "posthog_team"."autocapture_web_vitals_opt_in",
-         "posthog_team"."autocapture_web_vitals_allowed_metrics",
-         "posthog_team"."autocapture_exceptions_opt_in",
-         "posthog_team"."autocapture_exceptions_errors_to_ignore",
-         "posthog_team"."person_processing_opt_out",
-         "posthog_team"."session_recording_opt_in",
-         "posthog_team"."session_recording_sample_rate",
-         "posthog_team"."session_recording_minimum_duration_milliseconds",
-         "posthog_team"."session_recording_linked_flag",
-         "posthog_team"."session_recording_network_payload_capture_config",
-         "posthog_team"."session_recording_url_trigger_config",
-         "posthog_team"."session_recording_url_blocklist_config",
-         "posthog_team"."session_recording_event_trigger_config",
-         "posthog_team"."session_replay_config",
-         "posthog_team"."survey_config",
-         "posthog_team"."capture_console_log_opt_in",
-         "posthog_team"."capture_performance_opt_in",
-         "posthog_team"."capture_dead_clicks",
-         "posthog_team"."surveys_opt_in",
-         "posthog_team"."heatmaps_opt_in",
-         "posthog_team"."session_recording_version",
-         "posthog_team"."signup_token",
-         "posthog_team"."is_demo",
-         "posthog_team"."access_control",
-         "posthog_team"."week_start_day",
-         "posthog_team"."inject_web_apps",
-         "posthog_team"."test_account_filters",
-         "posthog_team"."test_account_filters_default_checked",
-         "posthog_team"."path_cleaning_filters",
-         "posthog_team"."timezone",
-         "posthog_team"."data_attributes",
-         "posthog_team"."person_display_name_properties",
-         "posthog_team"."live_events_columns",
-         "posthog_team"."recording_domains",
-         "posthog_team"."primary_dashboard_id",
-         "posthog_team"."extra_settings",
-         "posthog_team"."modifiers",
-         "posthog_team"."correlation_config",
-         "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
-         "posthog_team"."external_data_workspace_id",
-         "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
-  '''
-# ---
 # name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_iterator.6
   '''
   SELECT "posthog_person"."id",
@@ -589,6 +530,15 @@
   '''
 # ---
 # name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."project_id"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.1
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -606,12 +556,70 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."key" = 'some-feature-new'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.1
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.10
+  '''
+  SELECT "posthog_person"."id",
+         "posthog_person"."created_at",
+         "posthog_person"."properties_last_updated_at",
+         "posthog_person"."properties_last_operation",
+         "posthog_person"."team_id",
+         "posthog_person"."properties",
+         "posthog_person"."is_user_id",
+         "posthog_person"."is_identified",
+         "posthog_person"."uuid",
+         "posthog_person"."version"
+  FROM "posthog_person"
+  WHERE ("posthog_person"."team_id" = 99999
+         AND ((("posthog_person"."properties" -> 'group') = '"none"'::jsonb
+               AND "posthog_person"."properties" ? 'group'
+               AND NOT (("posthog_person"."properties" -> 'group') = 'null'::jsonb))
+              OR (("posthog_person"."properties" -> 'group2') IN ('1'::jsonb,
+                                                                  '2'::jsonb,
+                                                                  '3'::jsonb)
+                  AND "posthog_person"."properties" ? 'group2'
+                  AND NOT (("posthog_person"."properties" -> 'group2') = 'null'::jsonb))
+              OR EXISTS
+                (SELECT 1 AS "a"
+                 FROM "posthog_cohortpeople" U0
+                 WHERE (U0."cohort_id" = 99999
+                        AND U0."cohort_id" = 99999
+                        AND U0."person_id" = ("posthog_person"."id"))
+                 LIMIT 1)
+              OR (("posthog_person"."properties" -> 'does-not-exist') = '"none"'::jsonb
+                  AND "posthog_person"."properties" ? 'does-not-exist'
+                  AND NOT (("posthog_person"."properties" -> 'does-not-exist') = 'null'::jsonb))
+              OR (("posthog_person"."properties" -> 'key') = '"value"'::jsonb
+                  AND "posthog_person"."properties" ? 'key'
+                  AND NOT (("posthog_person"."properties" -> 'key') = 'null'::jsonb))))
+  ORDER BY "posthog_person"."id" ASC
+  LIMIT 1000
+  OFFSET 1000
+  '''
+# ---
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.11
+  '''
+  SELECT "posthog_person"."uuid"
+  FROM "posthog_person"
+  WHERE ("posthog_person"."team_id" = 99999
+         AND "posthog_person"."uuid" IN ('00000000000040008000000000000000'::uuid,
+                                         '00000000000040008000000000000001'::uuid,
+                                         '00000000000040008000000000000002'::uuid,
+                                         '00000000000040008000000000000003'::uuid)
+         AND NOT (EXISTS
+                    (SELECT 1 AS "a"
+                     FROM "posthog_cohortpeople" U1
+                     WHERE (U1."cohort_id" = 99999
+                            AND U1."person_id" = ("posthog_person"."id"))
+                     LIMIT 1)))
+  '''
+# ---
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.2
   '''
   SELECT "posthog_cohort"."id",
          "posthog_cohort"."name",
@@ -632,99 +640,13 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE ("posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.10
-  '''
-  SELECT "posthog_person"."uuid"
-  FROM "posthog_person"
-  WHERE ("posthog_person"."team_id" = 99999
-         AND "posthog_person"."uuid" IN ('00000000000040008000000000000000'::uuid,
-                                         '00000000000040008000000000000001'::uuid,
-                                         '00000000000040008000000000000002'::uuid,
-                                         '00000000000040008000000000000003'::uuid)
-         AND NOT (EXISTS
-                    (SELECT 1 AS "a"
-                     FROM "posthog_cohortpeople" U1
-                     WHERE (U1."cohort_id" = 99999
-                            AND U1."person_id" = ("posthog_person"."id"))
-                     LIMIT 1)))
-  '''
-# ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.11
-  '''
-  SELECT "posthog_team"."id",
-         "posthog_team"."uuid",
-         "posthog_team"."organization_id",
-         "posthog_team"."project_id",
-         "posthog_team"."api_token",
-         "posthog_team"."app_urls",
-         "posthog_team"."name",
-         "posthog_team"."slack_incoming_webhook",
-         "posthog_team"."created_at",
-         "posthog_team"."updated_at",
-         "posthog_team"."anonymize_ips",
-         "posthog_team"."completed_snippet_onboarding",
-         "posthog_team"."has_completed_onboarding_for",
-         "posthog_team"."ingested_event",
-         "posthog_team"."autocapture_opt_out",
-         "posthog_team"."autocapture_web_vitals_opt_in",
-         "posthog_team"."autocapture_web_vitals_allowed_metrics",
-         "posthog_team"."autocapture_exceptions_opt_in",
-         "posthog_team"."autocapture_exceptions_errors_to_ignore",
-         "posthog_team"."person_processing_opt_out",
-         "posthog_team"."session_recording_opt_in",
-         "posthog_team"."session_recording_sample_rate",
-         "posthog_team"."session_recording_minimum_duration_milliseconds",
-         "posthog_team"."session_recording_linked_flag",
-         "posthog_team"."session_recording_network_payload_capture_config",
-         "posthog_team"."session_recording_url_trigger_config",
-         "posthog_team"."session_recording_url_blocklist_config",
-         "posthog_team"."session_recording_event_trigger_config",
-         "posthog_team"."session_replay_config",
-         "posthog_team"."survey_config",
-         "posthog_team"."capture_console_log_opt_in",
-         "posthog_team"."capture_performance_opt_in",
-         "posthog_team"."capture_dead_clicks",
-         "posthog_team"."surveys_opt_in",
-         "posthog_team"."heatmaps_opt_in",
-         "posthog_team"."session_recording_version",
-         "posthog_team"."signup_token",
-         "posthog_team"."is_demo",
-         "posthog_team"."access_control",
-         "posthog_team"."week_start_day",
-         "posthog_team"."inject_web_apps",
-         "posthog_team"."test_account_filters",
-         "posthog_team"."test_account_filters_default_checked",
-         "posthog_team"."path_cleaning_filters",
-         "posthog_team"."timezone",
-         "posthog_team"."data_attributes",
-         "posthog_team"."person_display_name_properties",
-         "posthog_team"."live_events_columns",
-         "posthog_team"."recording_domains",
-         "posthog_team"."primary_dashboard_id",
-         "posthog_team"."extra_settings",
-         "posthog_team"."modifiers",
-         "posthog_team"."correlation_config",
-         "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
-         "posthog_team"."external_data_workspace_id",
-         "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.2
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.3
   '''
   SELECT "posthog_cohort"."id",
          "posthog_cohort"."name",
@@ -745,11 +667,12 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_cohort"."deleted"
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.3
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.4
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -788,7 +711,7 @@
   LIMIT 1000
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.4
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.5
   '''
   SELECT "posthog_persondistinctid"."id",
          "posthog_persondistinctid"."team_id",
@@ -808,7 +731,7 @@
                                                         5 /* ... */))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.5
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.6
   '''
   SELECT ("posthog_person"."id" IS NULL
           OR "posthog_person"."id" IS NULL
@@ -827,7 +750,7 @@
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.6
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.7
   '''
   SELECT ("posthog_person"."id" IS NOT NULL
           OR "posthog_person"."id" IS NULL
@@ -846,7 +769,7 @@
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.7
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.8
   '''
   SELECT ("posthog_person"."id" IS NULL
           OR "posthog_person"."id" IS NOT NULL
@@ -865,7 +788,7 @@
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.8
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.9
   '''
   SELECT ("posthog_person"."id" IS NULL
           OR "posthog_person"."id" IS NULL
@@ -884,47 +807,16 @@
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_cohort_flag_adds_cohort_props_as_default_too.9
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment
   '''
-  SELECT "posthog_person"."id",
-         "posthog_person"."created_at",
-         "posthog_person"."properties_last_updated_at",
-         "posthog_person"."properties_last_operation",
-         "posthog_person"."team_id",
-         "posthog_person"."properties",
-         "posthog_person"."is_user_id",
-         "posthog_person"."is_identified",
-         "posthog_person"."uuid",
-         "posthog_person"."version"
-  FROM "posthog_person"
-  WHERE ("posthog_person"."team_id" = 99999
-         AND ((("posthog_person"."properties" -> 'group') = '"none"'::jsonb
-               AND "posthog_person"."properties" ? 'group'
-               AND NOT (("posthog_person"."properties" -> 'group') = 'null'::jsonb))
-              OR (("posthog_person"."properties" -> 'group2') IN ('1'::jsonb,
-                                                                  '2'::jsonb,
-                                                                  '3'::jsonb)
-                  AND "posthog_person"."properties" ? 'group2'
-                  AND NOT (("posthog_person"."properties" -> 'group2') = 'null'::jsonb))
-              OR EXISTS
-                (SELECT 1 AS "a"
-                 FROM "posthog_cohortpeople" U0
-                 WHERE (U0."cohort_id" = 99999
-                        AND U0."cohort_id" = 99999
-                        AND U0."person_id" = ("posthog_person"."id"))
-                 LIMIT 1)
-              OR (("posthog_person"."properties" -> 'does-not-exist') = '"none"'::jsonb
-                  AND "posthog_person"."properties" ? 'does-not-exist'
-                  AND NOT (("posthog_person"."properties" -> 'does-not-exist') = 'null'::jsonb))
-              OR (("posthog_person"."properties" -> 'key') = '"value"'::jsonb
-                  AND "posthog_person"."properties" ? 'key'
-                  AND NOT (("posthog_person"."properties" -> 'key') = 'null'::jsonb))))
-  ORDER BY "posthog_person"."id" ASC
-  LIMIT 1000
-  OFFSET 1000
+  SELECT "posthog_team"."id",
+         "posthog_team"."project_id"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.1
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -942,38 +834,32 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."key" = 'some-feature2'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.1
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.10
   '''
-  SELECT "posthog_cohort"."id",
-         "posthog_cohort"."name",
-         "posthog_cohort"."description",
-         "posthog_cohort"."team_id",
-         "posthog_cohort"."deleted",
-         "posthog_cohort"."filters",
-         "posthog_cohort"."query",
-         "posthog_cohort"."version",
-         "posthog_cohort"."pending_version",
-         "posthog_cohort"."count",
-         "posthog_cohort"."created_by_id",
-         "posthog_cohort"."created_at",
-         "posthog_cohort"."is_calculating",
-         "posthog_cohort"."last_calculation",
-         "posthog_cohort"."errors_calculating",
-         "posthog_cohort"."last_error_at",
-         "posthog_cohort"."is_static",
-         "posthog_cohort"."groups"
-  FROM "posthog_cohort"
-  WHERE ("posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
-  LIMIT 21
+  SELECT "posthog_person"."id",
+         "posthog_person"."created_at",
+         "posthog_person"."properties_last_updated_at",
+         "posthog_person"."properties_last_operation",
+         "posthog_person"."team_id",
+         "posthog_person"."properties",
+         "posthog_person"."is_user_id",
+         "posthog_person"."is_identified",
+         "posthog_person"."uuid",
+         "posthog_person"."version"
+  FROM "posthog_person"
+  WHERE ("posthog_person"."team_id" = 99999
+         AND ("posthog_person"."properties" -> 'key') IS NOT NULL)
+  ORDER BY "posthog_person"."id" ASC
+  LIMIT 1000
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.10
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.11
   '''
   SELECT "posthog_persondistinctid"."id",
          "posthog_persondistinctid"."team_id",
@@ -993,7 +879,7 @@
                                                         5 /* ... */))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.11
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.12
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -1013,7 +899,7 @@
   OFFSET 1000
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.12
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.13
   '''
   SELECT "posthog_person"."uuid"
   FROM "posthog_person"
@@ -1028,77 +914,34 @@
                      LIMIT 1)))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.13
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.2
   '''
-  SELECT "posthog_team"."id",
-         "posthog_team"."uuid",
-         "posthog_team"."organization_id",
-         "posthog_team"."project_id",
-         "posthog_team"."api_token",
-         "posthog_team"."app_urls",
-         "posthog_team"."name",
-         "posthog_team"."slack_incoming_webhook",
-         "posthog_team"."created_at",
-         "posthog_team"."updated_at",
-         "posthog_team"."anonymize_ips",
-         "posthog_team"."completed_snippet_onboarding",
-         "posthog_team"."has_completed_onboarding_for",
-         "posthog_team"."ingested_event",
-         "posthog_team"."autocapture_opt_out",
-         "posthog_team"."autocapture_web_vitals_opt_in",
-         "posthog_team"."autocapture_web_vitals_allowed_metrics",
-         "posthog_team"."autocapture_exceptions_opt_in",
-         "posthog_team"."autocapture_exceptions_errors_to_ignore",
-         "posthog_team"."person_processing_opt_out",
-         "posthog_team"."session_recording_opt_in",
-         "posthog_team"."session_recording_sample_rate",
-         "posthog_team"."session_recording_minimum_duration_milliseconds",
-         "posthog_team"."session_recording_linked_flag",
-         "posthog_team"."session_recording_network_payload_capture_config",
-         "posthog_team"."session_recording_url_trigger_config",
-         "posthog_team"."session_recording_url_blocklist_config",
-         "posthog_team"."session_recording_event_trigger_config",
-         "posthog_team"."session_replay_config",
-         "posthog_team"."survey_config",
-         "posthog_team"."capture_console_log_opt_in",
-         "posthog_team"."capture_performance_opt_in",
-         "posthog_team"."capture_dead_clicks",
-         "posthog_team"."surveys_opt_in",
-         "posthog_team"."heatmaps_opt_in",
-         "posthog_team"."session_recording_version",
-         "posthog_team"."signup_token",
-         "posthog_team"."is_demo",
-         "posthog_team"."access_control",
-         "posthog_team"."week_start_day",
-         "posthog_team"."inject_web_apps",
-         "posthog_team"."test_account_filters",
-         "posthog_team"."test_account_filters_default_checked",
-         "posthog_team"."path_cleaning_filters",
-         "posthog_team"."timezone",
-         "posthog_team"."data_attributes",
-         "posthog_team"."person_display_name_properties",
-         "posthog_team"."live_events_columns",
-         "posthog_team"."recording_domains",
-         "posthog_team"."primary_dashboard_id",
-         "posthog_team"."extra_settings",
-         "posthog_team"."modifiers",
-         "posthog_team"."correlation_config",
-         "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
-         "posthog_team"."external_data_workspace_id",
-         "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_cohort"."id" = 99999
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.2
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.3
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -1119,7 +962,7 @@
   LIMIT 1000
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.3
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.4
   '''
   SELECT "posthog_persondistinctid"."id",
          "posthog_persondistinctid"."team_id",
@@ -1139,7 +982,7 @@
                                                         5 /* ... */))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.4
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.5
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -1161,7 +1004,7 @@
   OFFSET 1000
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.5
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.6
   '''
   SELECT "posthog_person"."uuid"
   FROM "posthog_person"
@@ -1172,80 +1015,19 @@
                      FROM "posthog_cohortpeople" U1
                      WHERE (U1."cohort_id" = 99999
                             AND U1."person_id" = ("posthog_person"."id"))
-                     LIMIT 1)))
-  '''
-# ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.6
-  '''
-  SELECT "posthog_team"."id",
-         "posthog_team"."uuid",
-         "posthog_team"."organization_id",
-         "posthog_team"."project_id",
-         "posthog_team"."api_token",
-         "posthog_team"."app_urls",
-         "posthog_team"."name",
-         "posthog_team"."slack_incoming_webhook",
-         "posthog_team"."created_at",
-         "posthog_team"."updated_at",
-         "posthog_team"."anonymize_ips",
-         "posthog_team"."completed_snippet_onboarding",
-         "posthog_team"."has_completed_onboarding_for",
-         "posthog_team"."ingested_event",
-         "posthog_team"."autocapture_opt_out",
-         "posthog_team"."autocapture_web_vitals_opt_in",
-         "posthog_team"."autocapture_web_vitals_allowed_metrics",
-         "posthog_team"."autocapture_exceptions_opt_in",
-         "posthog_team"."autocapture_exceptions_errors_to_ignore",
-         "posthog_team"."person_processing_opt_out",
-         "posthog_team"."session_recording_opt_in",
-         "posthog_team"."session_recording_sample_rate",
-         "posthog_team"."session_recording_minimum_duration_milliseconds",
-         "posthog_team"."session_recording_linked_flag",
-         "posthog_team"."session_recording_network_payload_capture_config",
-         "posthog_team"."session_recording_url_trigger_config",
-         "posthog_team"."session_recording_url_blocklist_config",
-         "posthog_team"."session_recording_event_trigger_config",
-         "posthog_team"."session_replay_config",
-         "posthog_team"."survey_config",
-         "posthog_team"."capture_console_log_opt_in",
-         "posthog_team"."capture_performance_opt_in",
-         "posthog_team"."capture_dead_clicks",
-         "posthog_team"."surveys_opt_in",
-         "posthog_team"."heatmaps_opt_in",
-         "posthog_team"."session_recording_version",
-         "posthog_team"."signup_token",
-         "posthog_team"."is_demo",
-         "posthog_team"."access_control",
-         "posthog_team"."week_start_day",
-         "posthog_team"."inject_web_apps",
-         "posthog_team"."test_account_filters",
-         "posthog_team"."test_account_filters_default_checked",
-         "posthog_team"."path_cleaning_filters",
-         "posthog_team"."timezone",
-         "posthog_team"."data_attributes",
-         "posthog_team"."person_display_name_properties",
-         "posthog_team"."live_events_columns",
-         "posthog_team"."recording_domains",
-         "posthog_team"."primary_dashboard_id",
-         "posthog_team"."extra_settings",
-         "posthog_team"."modifiers",
-         "posthog_team"."correlation_config",
-         "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
-         "posthog_team"."external_data_workspace_id",
-         "posthog_team"."external_data_workspace_last_synced_at"
+                     LIMIT 1)))
+  '''
+# ---
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.7
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."project_id"
   FROM "posthog_team"
   WHERE "posthog_team"."id" = 99999
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.7
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.8
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -1263,12 +1045,13 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."key" = 'some-feature-new'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.8
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.9
   '''
   SELECT "posthog_cohort"."id",
          "posthog_cohort"."name",
@@ -1289,31 +1072,22 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE ("posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_default_person_properties_adjustment.9
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag
   '''
-  SELECT "posthog_person"."id",
-         "posthog_person"."created_at",
-         "posthog_person"."properties_last_updated_at",
-         "posthog_person"."properties_last_operation",
-         "posthog_person"."team_id",
-         "posthog_person"."properties",
-         "posthog_person"."is_user_id",
-         "posthog_person"."is_identified",
-         "posthog_person"."uuid",
-         "posthog_person"."version"
-  FROM "posthog_person"
-  WHERE ("posthog_person"."team_id" = 99999
-         AND ("posthog_person"."properties" -> 'key') IS NOT NULL)
-  ORDER BY "posthog_person"."id" ASC
-  LIMIT 1000
+  SELECT "posthog_team"."id",
+         "posthog_team"."project_id"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.1
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -1331,12 +1105,13 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."key" = 'some-feature2'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.1
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.2
   '''
   SELECT "posthog_cohort"."id",
          "posthog_cohort"."name",
@@ -1357,12 +1132,13 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE ("posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.2
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.3
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -1383,7 +1159,7 @@
   LIMIT 1000
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.3
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.4
   '''
   SELECT "posthog_persondistinctid"."id",
          "posthog_persondistinctid"."team_id",
@@ -1403,7 +1179,7 @@
                                                         5 /* ... */))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.4
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.5
   '''
   SELECT "posthog_featureflaghashkeyoverride"."feature_flag_key",
          "posthog_featureflaghashkeyoverride"."hash_key",
@@ -1417,7 +1193,7 @@
          AND "posthog_featureflaghashkeyoverride"."team_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.5
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.6
   '''
   SELECT "posthog_featureflaghashkeyoverride"."feature_flag_key",
          "posthog_featureflaghashkeyoverride"."hash_key",
@@ -1431,7 +1207,7 @@
          AND "posthog_featureflaghashkeyoverride"."team_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.6
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.7
   '''
   SELECT "posthog_featureflaghashkeyoverride"."feature_flag_key",
          "posthog_featureflaghashkeyoverride"."hash_key",
@@ -1445,7 +1221,7 @@
          AND "posthog_featureflaghashkeyoverride"."team_id" = 99999)
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.7
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.8
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -1467,7 +1243,7 @@
   OFFSET 1000
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.8
+# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.9
   '''
   SELECT "posthog_person"."uuid"
   FROM "posthog_person"
@@ -1481,76 +1257,6 @@
                      LIMIT 1)))
   '''
 # ---
-# name: TestCohortGenerationForFeatureFlag.test_creating_static_cohort_with_experience_continuity_flag.9
-  '''
-  SELECT "posthog_team"."id",
-         "posthog_team"."uuid",
-         "posthog_team"."organization_id",
-         "posthog_team"."project_id",
-         "posthog_team"."api_token",
-         "posthog_team"."app_urls",
-         "posthog_team"."name",
-         "posthog_team"."slack_incoming_webhook",
-         "posthog_team"."created_at",
-         "posthog_team"."updated_at",
-         "posthog_team"."anonymize_ips",
-         "posthog_team"."completed_snippet_onboarding",
-         "posthog_team"."has_completed_onboarding_for",
-         "posthog_team"."ingested_event",
-         "posthog_team"."autocapture_opt_out",
-         "posthog_team"."autocapture_web_vitals_opt_in",
-         "posthog_team"."autocapture_web_vitals_allowed_metrics",
-         "posthog_team"."autocapture_exceptions_opt_in",
-         "posthog_team"."autocapture_exceptions_errors_to_ignore",
-         "posthog_team"."person_processing_opt_out",
-         "posthog_team"."session_recording_opt_in",
-         "posthog_team"."session_recording_sample_rate",
-         "posthog_team"."session_recording_minimum_duration_milliseconds",
-         "posthog_team"."session_recording_linked_flag",
-         "posthog_team"."session_recording_network_payload_capture_config",
-         "posthog_team"."session_recording_url_trigger_config",
-         "posthog_team"."session_recording_url_blocklist_config",
-         "posthog_team"."session_recording_event_trigger_config",
-         "posthog_team"."session_replay_config",
-         "posthog_team"."survey_config",
-         "posthog_team"."capture_console_log_opt_in",
-         "posthog_team"."capture_performance_opt_in",
-         "posthog_team"."capture_dead_clicks",
-         "posthog_team"."surveys_opt_in",
-         "posthog_team"."heatmaps_opt_in",
-         "posthog_team"."session_recording_version",
-         "posthog_team"."signup_token",
-         "posthog_team"."is_demo",
-         "posthog_team"."access_control",
-         "posthog_team"."week_start_day",
-         "posthog_team"."inject_web_apps",
-         "posthog_team"."test_account_filters",
-         "posthog_team"."test_account_filters_default_checked",
-         "posthog_team"."path_cleaning_filters",
-         "posthog_team"."timezone",
-         "posthog_team"."data_attributes",
-         "posthog_team"."person_display_name_properties",
-         "posthog_team"."live_events_columns",
-         "posthog_team"."recording_domains",
-         "posthog_team"."primary_dashboard_id",
-         "posthog_team"."extra_settings",
-         "posthog_team"."modifiers",
-         "posthog_team"."correlation_config",
-         "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
-         "posthog_team"."external_data_workspace_id",
-         "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
-  '''
-# ---
 # name: TestFeatureFlag.test_cant_create_flag_with_data_that_fails_to_query
   '''
   SELECT (("posthog_person"."properties" ->> 'email')::text ~ '2.3.9{0-9}{1}'
@@ -1668,6 +1374,33 @@
   '''
 # ---
 # name: TestFeatureFlag.test_creating_static_cohort.10
+  '''
+  SELECT "posthog_cohort"."id",
+         "posthog_cohort"."name",
+         "posthog_cohort"."description",
+         "posthog_cohort"."team_id",
+         "posthog_cohort"."deleted",
+         "posthog_cohort"."filters",
+         "posthog_cohort"."query",
+         "posthog_cohort"."version",
+         "posthog_cohort"."pending_version",
+         "posthog_cohort"."count",
+         "posthog_cohort"."created_by_id",
+         "posthog_cohort"."created_at",
+         "posthog_cohort"."is_calculating",
+         "posthog_cohort"."last_calculation",
+         "posthog_cohort"."errors_calculating",
+         "posthog_cohort"."last_error_at",
+         "posthog_cohort"."is_static",
+         "posthog_cohort"."groups"
+  FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_cohort"."id" = 99999
+         AND "posthog_team"."project_id" = 99999)
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlag.test_creating_static_cohort.11
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -1688,7 +1421,7 @@
   LIMIT 10000
   '''
 # ---
-# name: TestFeatureFlag.test_creating_static_cohort.11
+# name: TestFeatureFlag.test_creating_static_cohort.12
   '''
   SELECT "posthog_persondistinctid"."id",
          "posthog_persondistinctid"."team_id",
@@ -1708,7 +1441,7 @@
                                                         5 /* ... */))
   '''
 # ---
-# name: TestFeatureFlag.test_creating_static_cohort.12
+# name: TestFeatureFlag.test_creating_static_cohort.13
   '''
   SELECT "posthog_person"."id",
          "posthog_person"."created_at",
@@ -1730,7 +1463,7 @@
   OFFSET 10000
   '''
 # ---
-# name: TestFeatureFlag.test_creating_static_cohort.13
+# name: TestFeatureFlag.test_creating_static_cohort.14
   '''
   SELECT "posthog_person"."uuid"
   FROM "posthog_person"
@@ -1744,76 +1477,6 @@
                      LIMIT 1)))
   '''
 # ---
-# name: TestFeatureFlag.test_creating_static_cohort.14
-  '''
-  SELECT "posthog_team"."id",
-         "posthog_team"."uuid",
-         "posthog_team"."organization_id",
-         "posthog_team"."project_id",
-         "posthog_team"."api_token",
-         "posthog_team"."app_urls",
-         "posthog_team"."name",
-         "posthog_team"."slack_incoming_webhook",
-         "posthog_team"."created_at",
-         "posthog_team"."updated_at",
-         "posthog_team"."anonymize_ips",
-         "posthog_team"."completed_snippet_onboarding",
-         "posthog_team"."has_completed_onboarding_for",
-         "posthog_team"."ingested_event",
-         "posthog_team"."autocapture_opt_out",
-         "posthog_team"."autocapture_web_vitals_opt_in",
-         "posthog_team"."autocapture_web_vitals_allowed_metrics",
-         "posthog_team"."autocapture_exceptions_opt_in",
-         "posthog_team"."autocapture_exceptions_errors_to_ignore",
-         "posthog_team"."person_processing_opt_out",
-         "posthog_team"."session_recording_opt_in",
-         "posthog_team"."session_recording_sample_rate",
-         "posthog_team"."session_recording_minimum_duration_milliseconds",
-         "posthog_team"."session_recording_linked_flag",
-         "posthog_team"."session_recording_network_payload_capture_config",
-         "posthog_team"."session_recording_url_trigger_config",
-         "posthog_team"."session_recording_url_blocklist_config",
-         "posthog_team"."session_recording_event_trigger_config",
-         "posthog_team"."session_replay_config",
-         "posthog_team"."survey_config",
-         "posthog_team"."capture_console_log_opt_in",
-         "posthog_team"."capture_performance_opt_in",
-         "posthog_team"."capture_dead_clicks",
-         "posthog_team"."surveys_opt_in",
-         "posthog_team"."heatmaps_opt_in",
-         "posthog_team"."session_recording_version",
-         "posthog_team"."signup_token",
-         "posthog_team"."is_demo",
-         "posthog_team"."access_control",
-         "posthog_team"."week_start_day",
-         "posthog_team"."inject_web_apps",
-         "posthog_team"."test_account_filters",
-         "posthog_team"."test_account_filters_default_checked",
-         "posthog_team"."path_cleaning_filters",
-         "posthog_team"."timezone",
-         "posthog_team"."data_attributes",
-         "posthog_team"."person_display_name_properties",
-         "posthog_team"."live_events_columns",
-         "posthog_team"."recording_domains",
-         "posthog_team"."primary_dashboard_id",
-         "posthog_team"."extra_settings",
-         "posthog_team"."modifiers",
-         "posthog_team"."correlation_config",
-         "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
-         "posthog_team"."external_data_workspace_id",
-         "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
-  '''
-# ---
 # name: TestFeatureFlag.test_creating_static_cohort.15
   '''
   SELECT "posthog_team"."id",
@@ -2141,6 +1804,15 @@
   '''
 # ---
 # name: TestFeatureFlag.test_creating_static_cohort.8
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."project_id"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlag.test_creating_static_cohort.9
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -2158,34 +1830,9 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."key" = 'some-feature'
-         AND "posthog_featureflag"."team_id" = 99999)
-  LIMIT 21
-  '''
-# ---
-# name: TestFeatureFlag.test_creating_static_cohort.9
-  '''
-  SELECT "posthog_cohort"."id",
-         "posthog_cohort"."name",
-         "posthog_cohort"."description",
-         "posthog_cohort"."team_id",
-         "posthog_cohort"."deleted",
-         "posthog_cohort"."filters",
-         "posthog_cohort"."query",
-         "posthog_cohort"."version",
-         "posthog_cohort"."pending_version",
-         "posthog_cohort"."count",
-         "posthog_cohort"."created_by_id",
-         "posthog_cohort"."created_at",
-         "posthog_cohort"."is_calculating",
-         "posthog_cohort"."last_calculation",
-         "posthog_cohort"."errors_calculating",
-         "posthog_cohort"."last_error_at",
-         "posthog_cohort"."is_static",
-         "posthog_cohort"."groups"
-  FROM "posthog_cohort"
-  WHERE ("posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
diff --git a/posthog/api/test/__snapshots__/test_organization_feature_flag.ambr b/posthog/api/test/__snapshots__/test_organization_feature_flag.ambr
index 351264ee04d8c..5b8721a2cd48f 100644
--- a/posthog/api/test/__snapshots__/test_organization_feature_flag.ambr
+++ b/posthog/api/test/__snapshots__/test_organization_feature_flag.ambr
@@ -136,13 +136,6 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
@@ -152,53 +145,17 @@
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.12
   '''
-  SELECT "posthog_dashboardtile"."id"
-  FROM "posthog_dashboardtile"
-  INNER JOIN "posthog_dashboard" ON ("posthog_dashboardtile"."dashboard_id" = "posthog_dashboard"."id")
-  WHERE (NOT ("posthog_dashboardtile"."deleted"
-              AND "posthog_dashboardtile"."deleted" IS NOT NULL)
-         AND NOT ("posthog_dashboard"."deleted")
-         AND "posthog_dashboardtile"."dashboard_id" = 99999)
-  '''
-# ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.13
-  '''
-  SELECT "posthog_organization"."id",
-         "posthog_organization"."name",
-         "posthog_organization"."slug",
-         "posthog_organization"."logo_media_id",
-         "posthog_organization"."created_at",
-         "posthog_organization"."updated_at",
-         "posthog_organization"."plugins_access_level",
-         "posthog_organization"."for_internal_metrics",
-         "posthog_organization"."is_member_join_email_enabled",
-         "posthog_organization"."enforce_2fa",
-         "posthog_organization"."is_hipaa",
-         "posthog_organization"."customer_id",
-         "posthog_organization"."available_product_features",
-         "posthog_organization"."usage",
-         "posthog_organization"."never_drop_data",
-         "posthog_organization"."customer_trust_scores",
-         "posthog_organization"."setup_section_2_completed",
-         "posthog_organization"."personalization",
-         "posthog_organization"."domain_whitelist"
-  FROM "posthog_organization"
-  WHERE "posthog_organization"."id" = '00000000-0000-0000-0000-000000000000'::uuid
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.14
-  '''
-  SELECT "posthog_dashboardtile"."id"
-  FROM "posthog_dashboardtile"
-  INNER JOIN "posthog_dashboard" ON ("posthog_dashboardtile"."dashboard_id" = "posthog_dashboard"."id")
-  WHERE (NOT ("posthog_dashboardtile"."deleted"
-              AND "posthog_dashboardtile"."deleted" IS NOT NULL)
-         AND NOT ("posthog_dashboard"."deleted")
-         AND "posthog_dashboardtile"."dashboard_id" = 99999)
-  '''
-# ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.15
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.13
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -254,6 +211,13 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
@@ -261,44 +225,139 @@
   LIMIT 21
   '''
 # ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.14
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.15
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.16
   '''
-  SELECT "posthog_dashboarditem"."id",
-         "posthog_dashboarditem"."name",
-         "posthog_dashboarditem"."derived_name",
-         "posthog_dashboarditem"."description",
-         "posthog_dashboarditem"."team_id",
-         "posthog_dashboarditem"."filters",
-         "posthog_dashboarditem"."filters_hash",
-         "posthog_dashboarditem"."query",
-         "posthog_dashboarditem"."order",
-         "posthog_dashboarditem"."deleted",
-         "posthog_dashboarditem"."saved",
-         "posthog_dashboarditem"."created_at",
-         "posthog_dashboarditem"."refreshing",
-         "posthog_dashboarditem"."created_by_id",
-         "posthog_dashboarditem"."is_sample",
-         "posthog_dashboarditem"."short_id",
-         "posthog_dashboarditem"."favorited",
-         "posthog_dashboarditem"."refresh_attempt",
-         "posthog_dashboarditem"."last_modified_at",
-         "posthog_dashboarditem"."last_modified_by_id",
-         "posthog_dashboarditem"."dashboard_id",
-         "posthog_dashboarditem"."last_refresh",
-         "posthog_dashboarditem"."layouts",
-         "posthog_dashboarditem"."color",
-         "posthog_dashboarditem"."dive_dashboard_id",
-         "posthog_dashboarditem"."updated_at",
-         "posthog_dashboarditem"."deprecated_tags",
-         "posthog_dashboarditem"."tags"
-  FROM "posthog_dashboarditem"
-  WHERE "posthog_dashboarditem"."id" = 99999
-  LIMIT 21
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.17
   '''
-  SELECT "posthog_team"."id",
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
          "posthog_team"."uuid",
          "posthog_team"."organization_id",
          "posthog_team"."project_id",
@@ -361,9 +420,12 @@
          "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.18
@@ -422,6 +484,13 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
@@ -431,20 +500,13 @@
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.19
   '''
-  SELECT "posthog_dashboardtile"."id",
-         "posthog_dashboardtile"."dashboard_id",
-         "posthog_dashboardtile"."insight_id",
-         "posthog_dashboardtile"."text_id",
-         "posthog_dashboardtile"."layouts",
-         "posthog_dashboardtile"."color",
-         "posthog_dashboardtile"."filters_hash",
-         "posthog_dashboardtile"."last_refresh",
-         "posthog_dashboardtile"."refreshing",
-         "posthog_dashboardtile"."refresh_attempt",
-         "posthog_dashboardtile"."deleted"
+  SELECT "posthog_dashboardtile"."id"
   FROM "posthog_dashboardtile"
-  WHERE "posthog_dashboardtile"."id" = 99999
-  LIMIT 21
+  INNER JOIN "posthog_dashboard" ON ("posthog_dashboardtile"."dashboard_id" = "posthog_dashboard"."id")
+  WHERE (NOT ("posthog_dashboardtile"."deleted"
+              AND "posthog_dashboardtile"."deleted" IS NOT NULL)
+         AND NOT ("posthog_dashboard"."deleted")
+         AND "posthog_dashboardtile"."dashboard_id" = 99999)
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.2
@@ -458,61 +520,39 @@
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.20
   '''
-  SELECT "posthog_dashboarditem"."id",
-         "posthog_dashboarditem"."name",
-         "posthog_dashboarditem"."derived_name",
-         "posthog_dashboarditem"."description",
-         "posthog_dashboarditem"."team_id",
-         "posthog_dashboarditem"."filters",
-         "posthog_dashboarditem"."filters_hash",
-         "posthog_dashboarditem"."query",
-         "posthog_dashboarditem"."order",
-         "posthog_dashboarditem"."deleted",
-         "posthog_dashboarditem"."saved",
-         "posthog_dashboarditem"."created_at",
-         "posthog_dashboarditem"."refreshing",
-         "posthog_dashboarditem"."created_by_id",
-         "posthog_dashboarditem"."is_sample",
-         "posthog_dashboarditem"."short_id",
-         "posthog_dashboarditem"."favorited",
-         "posthog_dashboarditem"."refresh_attempt",
-         "posthog_dashboarditem"."last_modified_at",
-         "posthog_dashboarditem"."last_modified_by_id",
-         "posthog_dashboarditem"."dashboard_id",
-         "posthog_dashboarditem"."last_refresh",
-         "posthog_dashboarditem"."layouts",
-         "posthog_dashboarditem"."color",
-         "posthog_dashboarditem"."dive_dashboard_id",
-         "posthog_dashboarditem"."updated_at",
-         "posthog_dashboarditem"."deprecated_tags",
-         "posthog_dashboarditem"."tags"
-  FROM "posthog_dashboarditem"
-  WHERE "posthog_dashboarditem"."id" = 99999
+  SELECT "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organization"
+  WHERE "posthog_organization"."id" = '00000000-0000-0000-0000-000000000000'::uuid
   LIMIT 21
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.21
   '''
-  SELECT "posthog_dashboard"."id",
-         "posthog_dashboard"."name",
-         "posthog_dashboard"."description",
-         "posthog_dashboard"."team_id",
-         "posthog_dashboard"."pinned",
-         "posthog_dashboard"."created_at",
-         "posthog_dashboard"."created_by_id",
-         "posthog_dashboard"."deleted",
-         "posthog_dashboard"."last_accessed_at",
-         "posthog_dashboard"."filters",
-         "posthog_dashboard"."variables",
-         "posthog_dashboard"."creation_mode",
-         "posthog_dashboard"."restriction_level",
-         "posthog_dashboard"."deprecated_tags",
-         "posthog_dashboard"."tags",
-         "posthog_dashboard"."share_token",
-         "posthog_dashboard"."is_shared"
-  FROM "posthog_dashboard"
-  WHERE "posthog_dashboard"."id" = 99999
-  LIMIT 21
+  SELECT "posthog_dashboardtile"."id"
+  FROM "posthog_dashboardtile"
+  INNER JOIN "posthog_dashboard" ON ("posthog_dashboardtile"."dashboard_id" = "posthog_dashboard"."id")
+  WHERE (NOT ("posthog_dashboardtile"."deleted"
+              AND "posthog_dashboardtile"."deleted" IS NOT NULL)
+         AND NOT ("posthog_dashboard"."deleted")
+         AND "posthog_dashboardtile"."dashboard_id" = 99999)
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.22
@@ -571,13 +611,6 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
@@ -586,69 +619,6 @@
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.23
-  '''
-  SELECT "posthog_team"."id",
-         "posthog_team"."uuid",
-         "posthog_team"."organization_id",
-         "posthog_team"."project_id",
-         "posthog_team"."api_token",
-         "posthog_team"."app_urls",
-         "posthog_team"."name",
-         "posthog_team"."slack_incoming_webhook",
-         "posthog_team"."created_at",
-         "posthog_team"."updated_at",
-         "posthog_team"."anonymize_ips",
-         "posthog_team"."completed_snippet_onboarding",
-         "posthog_team"."has_completed_onboarding_for",
-         "posthog_team"."ingested_event",
-         "posthog_team"."autocapture_opt_out",
-         "posthog_team"."autocapture_web_vitals_opt_in",
-         "posthog_team"."autocapture_web_vitals_allowed_metrics",
-         "posthog_team"."autocapture_exceptions_opt_in",
-         "posthog_team"."autocapture_exceptions_errors_to_ignore",
-         "posthog_team"."person_processing_opt_out",
-         "posthog_team"."session_recording_opt_in",
-         "posthog_team"."session_recording_sample_rate",
-         "posthog_team"."session_recording_minimum_duration_milliseconds",
-         "posthog_team"."session_recording_linked_flag",
-         "posthog_team"."session_recording_network_payload_capture_config",
-         "posthog_team"."session_recording_url_trigger_config",
-         "posthog_team"."session_recording_url_blocklist_config",
-         "posthog_team"."session_recording_event_trigger_config",
-         "posthog_team"."session_replay_config",
-         "posthog_team"."survey_config",
-         "posthog_team"."capture_console_log_opt_in",
-         "posthog_team"."capture_performance_opt_in",
-         "posthog_team"."capture_dead_clicks",
-         "posthog_team"."surveys_opt_in",
-         "posthog_team"."heatmaps_opt_in",
-         "posthog_team"."session_recording_version",
-         "posthog_team"."signup_token",
-         "posthog_team"."is_demo",
-         "posthog_team"."access_control",
-         "posthog_team"."week_start_day",
-         "posthog_team"."inject_web_apps",
-         "posthog_team"."test_account_filters",
-         "posthog_team"."test_account_filters_default_checked",
-         "posthog_team"."path_cleaning_filters",
-         "posthog_team"."timezone",
-         "posthog_team"."data_attributes",
-         "posthog_team"."person_display_name_properties",
-         "posthog_team"."live_events_columns",
-         "posthog_team"."recording_domains",
-         "posthog_team"."primary_dashboard_id",
-         "posthog_team"."extra_settings",
-         "posthog_team"."modifiers",
-         "posthog_team"."correlation_config",
-         "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."external_data_workspace_id",
-         "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.24
   '''
   SELECT "posthog_dashboarditem"."id",
          "posthog_dashboarditem"."name",
@@ -683,7 +653,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.25
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.24
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -753,7 +723,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.26
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.25
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -816,7 +786,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.27
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.26
   '''
   SELECT "posthog_dashboardtile"."id",
          "posthog_dashboardtile"."dashboard_id",
@@ -834,7 +804,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.28
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.27
   '''
   SELECT "posthog_dashboarditem"."id",
          "posthog_dashboarditem"."name",
@@ -869,7 +839,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.29
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.28
   '''
   SELECT "posthog_dashboard"."id",
          "posthog_dashboard"."name",
@@ -893,6 +863,76 @@
   LIMIT 21
   '''
 # ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.29
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.3
   '''
   SELECT "posthog_featureflag"."id",
@@ -911,8 +951,9 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."key" = 'copied-flag-key'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   LIMIT 21
   '''
 # ---
@@ -972,13 +1013,6 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
-         "posthog_team"."plugins_opt_in",
-         "posthog_team"."opt_out_capture",
-         "posthog_team"."event_names",
-         "posthog_team"."event_names_with_usage",
-         "posthog_team"."event_properties",
-         "posthog_team"."event_properties_with_usage",
-         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
@@ -988,25 +1022,37 @@
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.31
   '''
-  SELECT "posthog_featureflag"."id",
-         "posthog_featureflag"."key",
-         "posthog_featureflag"."name",
-         "posthog_featureflag"."filters",
-         "posthog_featureflag"."rollout_percentage",
-         "posthog_featureflag"."team_id",
-         "posthog_featureflag"."created_by_id",
-         "posthog_featureflag"."created_at",
-         "posthog_featureflag"."deleted",
-         "posthog_featureflag"."active",
-         "posthog_featureflag"."rollback_conditions",
-         "posthog_featureflag"."performed_rollback",
-         "posthog_featureflag"."ensure_experience_continuity",
-         "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+  SELECT "posthog_dashboarditem"."id",
+         "posthog_dashboarditem"."name",
+         "posthog_dashboarditem"."derived_name",
+         "posthog_dashboarditem"."description",
+         "posthog_dashboarditem"."team_id",
+         "posthog_dashboarditem"."filters",
+         "posthog_dashboarditem"."filters_hash",
+         "posthog_dashboarditem"."query",
+         "posthog_dashboarditem"."order",
+         "posthog_dashboarditem"."deleted",
+         "posthog_dashboarditem"."saved",
+         "posthog_dashboarditem"."created_at",
+         "posthog_dashboarditem"."refreshing",
+         "posthog_dashboarditem"."created_by_id",
+         "posthog_dashboarditem"."is_sample",
+         "posthog_dashboarditem"."short_id",
+         "posthog_dashboarditem"."favorited",
+         "posthog_dashboarditem"."refresh_attempt",
+         "posthog_dashboarditem"."last_modified_at",
+         "posthog_dashboarditem"."last_modified_by_id",
+         "posthog_dashboarditem"."dashboard_id",
+         "posthog_dashboarditem"."last_refresh",
+         "posthog_dashboarditem"."layouts",
+         "posthog_dashboarditem"."color",
+         "posthog_dashboarditem"."dive_dashboard_id",
+         "posthog_dashboarditem"."updated_at",
+         "posthog_dashboarditem"."deprecated_tags",
+         "posthog_dashboarditem"."tags"
+  FROM "posthog_dashboarditem"
+  WHERE "posthog_dashboarditem"."id" = 99999
+  LIMIT 21
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.32
@@ -1081,114 +1127,121 @@
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.33
   '''
-  SELECT "posthog_experiment"."id",
-         "posthog_experiment"."name",
-         "posthog_experiment"."description",
-         "posthog_experiment"."team_id",
-         "posthog_experiment"."filters",
-         "posthog_experiment"."parameters",
-         "posthog_experiment"."secondary_metrics",
-         "posthog_experiment"."created_by_id",
-         "posthog_experiment"."feature_flag_id",
-         "posthog_experiment"."exposure_cohort_id",
-         "posthog_experiment"."holdout_id",
-         "posthog_experiment"."start_date",
-         "posthog_experiment"."end_date",
-         "posthog_experiment"."created_at",
-         "posthog_experiment"."updated_at",
-         "posthog_experiment"."archived",
-         "posthog_experiment"."type",
-         "posthog_experiment"."variants",
-         "posthog_experiment"."metrics",
-         "posthog_experiment"."metrics_secondary"
-  FROM "posthog_experiment"
-  WHERE "posthog_experiment"."feature_flag_id" = 99999
-  '''
-# ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.34
-  '''
-  SELECT "posthog_survey"."id",
-         "posthog_survey"."team_id",
-         "posthog_survey"."name",
-         "posthog_survey"."description",
-         "posthog_survey"."linked_flag_id",
-         "posthog_survey"."targeting_flag_id",
-         "posthog_survey"."internal_targeting_flag_id",
-         "posthog_survey"."internal_response_sampling_flag_id",
-         "posthog_survey"."type",
-         "posthog_survey"."conditions",
-         "posthog_survey"."questions",
-         "posthog_survey"."appearance",
-         "posthog_survey"."created_at",
-         "posthog_survey"."created_by_id",
-         "posthog_survey"."start_date",
-         "posthog_survey"."end_date",
-         "posthog_survey"."updated_at",
-         "posthog_survey"."archived",
-         "posthog_survey"."responses_limit",
-         "posthog_survey"."response_sampling_start_date",
-         "posthog_survey"."response_sampling_interval_type",
-         "posthog_survey"."response_sampling_interval",
-         "posthog_survey"."response_sampling_limit",
-         "posthog_survey"."response_sampling_daily_limits",
-         "posthog_survey"."iteration_count",
-         "posthog_survey"."iteration_frequency_days",
-         "posthog_survey"."iteration_start_dates",
-         "posthog_survey"."current_iteration",
-         "posthog_survey"."current_iteration_start_date"
-  FROM "posthog_survey"
-  WHERE "posthog_survey"."linked_flag_id" = 99999
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.35
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.34
   '''
-  SELECT "posthog_earlyaccessfeature"."id",
-         "posthog_earlyaccessfeature"."team_id",
-         "posthog_earlyaccessfeature"."feature_flag_id",
-         "posthog_earlyaccessfeature"."name",
-         "posthog_earlyaccessfeature"."description",
-         "posthog_earlyaccessfeature"."stage",
-         "posthog_earlyaccessfeature"."documentation_url",
-         "posthog_earlyaccessfeature"."created_at"
-  FROM "posthog_earlyaccessfeature"
-  WHERE "posthog_earlyaccessfeature"."feature_flag_id" = 99999
+  SELECT "posthog_dashboardtile"."id",
+         "posthog_dashboardtile"."dashboard_id",
+         "posthog_dashboardtile"."insight_id",
+         "posthog_dashboardtile"."text_id",
+         "posthog_dashboardtile"."layouts",
+         "posthog_dashboardtile"."color",
+         "posthog_dashboardtile"."filters_hash",
+         "posthog_dashboardtile"."last_refresh",
+         "posthog_dashboardtile"."refreshing",
+         "posthog_dashboardtile"."refresh_attempt",
+         "posthog_dashboardtile"."deleted"
+  FROM "posthog_dashboardtile"
+  WHERE "posthog_dashboardtile"."id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.36
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.35
   '''
-  SELECT "posthog_organizationmembership"."id",
-         "posthog_organizationmembership"."organization_id",
-         "posthog_organizationmembership"."user_id",
-         "posthog_organizationmembership"."level",
-         "posthog_organizationmembership"."joined_at",
-         "posthog_organizationmembership"."updated_at",
-         "posthog_organization"."id",
-         "posthog_organization"."name",
-         "posthog_organization"."slug",
-         "posthog_organization"."logo_media_id",
-         "posthog_organization"."created_at",
-         "posthog_organization"."updated_at",
-         "posthog_organization"."plugins_access_level",
-         "posthog_organization"."for_internal_metrics",
-         "posthog_organization"."is_member_join_email_enabled",
-         "posthog_organization"."enforce_2fa",
-         "posthog_organization"."is_hipaa",
-         "posthog_organization"."customer_id",
-         "posthog_organization"."available_product_features",
-         "posthog_organization"."usage",
-         "posthog_organization"."never_drop_data",
-         "posthog_organization"."customer_trust_scores",
-         "posthog_organization"."setup_section_2_completed",
-         "posthog_organization"."personalization",
-         "posthog_organization"."domain_whitelist"
-  FROM "posthog_organizationmembership"
-  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
-  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
-         AND "posthog_organizationmembership"."user_id" = 99999)
+  SELECT "posthog_dashboarditem"."id",
+         "posthog_dashboarditem"."name",
+         "posthog_dashboarditem"."derived_name",
+         "posthog_dashboarditem"."description",
+         "posthog_dashboarditem"."team_id",
+         "posthog_dashboarditem"."filters",
+         "posthog_dashboarditem"."filters_hash",
+         "posthog_dashboarditem"."query",
+         "posthog_dashboarditem"."order",
+         "posthog_dashboarditem"."deleted",
+         "posthog_dashboarditem"."saved",
+         "posthog_dashboarditem"."created_at",
+         "posthog_dashboarditem"."refreshing",
+         "posthog_dashboarditem"."created_by_id",
+         "posthog_dashboarditem"."is_sample",
+         "posthog_dashboarditem"."short_id",
+         "posthog_dashboarditem"."favorited",
+         "posthog_dashboarditem"."refresh_attempt",
+         "posthog_dashboarditem"."last_modified_at",
+         "posthog_dashboarditem"."last_modified_by_id",
+         "posthog_dashboarditem"."dashboard_id",
+         "posthog_dashboarditem"."last_refresh",
+         "posthog_dashboarditem"."layouts",
+         "posthog_dashboarditem"."color",
+         "posthog_dashboarditem"."dive_dashboard_id",
+         "posthog_dashboarditem"."updated_at",
+         "posthog_dashboarditem"."deprecated_tags",
+         "posthog_dashboarditem"."tags"
+  FROM "posthog_dashboarditem"
+  WHERE "posthog_dashboarditem"."id" = 99999
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.37
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.36
   '''
   SELECT "posthog_dashboard"."id",
          "posthog_dashboard"."name",
@@ -1208,56 +1261,166 @@
          "posthog_dashboard"."share_token",
          "posthog_dashboard"."is_shared"
   FROM "posthog_dashboard"
-  INNER JOIN "posthog_featureflagdashboards" ON ("posthog_dashboard"."id" = "posthog_featureflagdashboards"."dashboard_id")
-  WHERE (NOT ("posthog_dashboard"."deleted")
-         AND "posthog_featureflagdashboards"."feature_flag_id" = 99999)
+  WHERE "posthog_dashboard"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.37
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.38
   '''
-  SELECT "posthog_organizationmembership"."id",
-         "posthog_organizationmembership"."organization_id",
-         "posthog_organizationmembership"."user_id",
-         "posthog_organizationmembership"."level",
-         "posthog_organizationmembership"."joined_at",
-         "posthog_organizationmembership"."updated_at",
-         "posthog_organization"."id",
-         "posthog_organization"."name",
-         "posthog_organization"."slug",
-         "posthog_organization"."logo_media_id",
-         "posthog_organization"."created_at",
-         "posthog_organization"."updated_at",
-         "posthog_organization"."plugins_access_level",
-         "posthog_organization"."for_internal_metrics",
-         "posthog_organization"."is_member_join_email_enabled",
-         "posthog_organization"."enforce_2fa",
-         "posthog_organization"."is_hipaa",
-         "posthog_organization"."customer_id",
-         "posthog_organization"."available_product_features",
-         "posthog_organization"."usage",
-         "posthog_organization"."never_drop_data",
-         "posthog_organization"."customer_trust_scores",
-         "posthog_organization"."setup_section_2_completed",
-         "posthog_organization"."personalization",
-         "posthog_organization"."domain_whitelist"
-  FROM "posthog_organizationmembership"
-  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
-  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
-         AND "posthog_organizationmembership"."user_id" = 99999)
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.39
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
   LIMIT 21
   '''
 # ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.39
-  '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
-  '''
-# ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.4
   '''
   SELECT "posthog_organization"."id",
@@ -1286,27 +1449,17 @@
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.40
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_V2_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.41
-  '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
-  '''
-# ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.42
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -1323,16 +1476,24 @@
          "posthog_team"."has_completed_onboarding_for",
          "posthog_team"."ingested_event",
          "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
          "posthog_team"."autocapture_exceptions_opt_in",
          "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
          "posthog_team"."session_recording_opt_in",
          "posthog_team"."session_recording_sample_rate",
          "posthog_team"."session_recording_minimum_duration_milliseconds",
          "posthog_team"."session_recording_linked_flag",
          "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
          "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
          "posthog_team"."capture_console_log_opt_in",
          "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
          "posthog_team"."surveys_opt_in",
          "posthog_team"."heatmaps_opt_in",
          "posthog_team"."session_recording_version",
@@ -1354,51 +1515,153 @@
          "posthog_team"."modifiers",
          "posthog_team"."correlation_config",
          "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
-  WHERE "posthog_team"."id" = 2
+  WHERE "posthog_team"."id" = 99999
   LIMIT 21
   '''
 # ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.42
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.43
   '''
-  SELECT "posthog_dashboarditem"."id",
-         "posthog_dashboarditem"."name",
-         "posthog_dashboarditem"."derived_name",
-         "posthog_dashboarditem"."description",
-         "posthog_dashboarditem"."team_id",
-         "posthog_dashboarditem"."filters",
-         "posthog_dashboarditem"."filters_hash",
-         "posthog_dashboarditem"."query",
-         "posthog_dashboarditem"."order",
-         "posthog_dashboarditem"."deleted",
-         "posthog_dashboarditem"."saved",
-         "posthog_dashboarditem"."created_at",
-         "posthog_dashboarditem"."last_refresh",
-         "posthog_dashboarditem"."refreshing",
-         "posthog_dashboarditem"."created_by_id",
-         "posthog_dashboarditem"."is_sample",
-         "posthog_dashboarditem"."short_id",
-         "posthog_dashboarditem"."favorited",
-         "posthog_dashboarditem"."refresh_attempt",
-         "posthog_dashboarditem"."last_modified_at",
-         "posthog_dashboarditem"."last_modified_by_id",
-         "posthog_dashboarditem"."dashboard_id",
-         "posthog_dashboarditem"."layouts",
-         "posthog_dashboarditem"."color",
-         "posthog_dashboarditem"."dive_dashboard_id",
-         "posthog_dashboarditem"."updated_at",
-         "posthog_dashboarditem"."deprecated_tags",
-         "posthog_dashboarditem"."tags"
-  FROM "posthog_dashboarditem"
-  WHERE "posthog_dashboarditem"."id" = 2
-  LIMIT 21
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.44
   '''
-  SELECT "posthog_team"."id",
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.45
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
          "posthog_team"."uuid",
          "posthog_team"."organization_id",
          "posthog_team"."project_id",
@@ -1413,16 +1676,24 @@
          "posthog_team"."has_completed_onboarding_for",
          "posthog_team"."ingested_event",
          "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
          "posthog_team"."autocapture_exceptions_opt_in",
          "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
          "posthog_team"."session_recording_opt_in",
          "posthog_team"."session_recording_sample_rate",
          "posthog_team"."session_recording_minimum_duration_milliseconds",
          "posthog_team"."session_recording_linked_flag",
          "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
          "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
          "posthog_team"."capture_console_log_opt_in",
          "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
          "posthog_team"."surveys_opt_in",
          "posthog_team"."heatmaps_opt_in",
          "posthog_team"."session_recording_version",
@@ -1453,64 +1724,157 @@
          "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 2
-  LIMIT 21
-  '''
-# ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.45
-  '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_V2_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.46
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
-  '''
-# ---
-# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.47
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_V2_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+# ---
+# name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.47
+  '''
+  SELECT "posthog_experiment"."id",
+         "posthog_experiment"."name",
+         "posthog_experiment"."description",
+         "posthog_experiment"."team_id",
+         "posthog_experiment"."filters",
+         "posthog_experiment"."parameters",
+         "posthog_experiment"."secondary_metrics",
+         "posthog_experiment"."created_by_id",
+         "posthog_experiment"."feature_flag_id",
+         "posthog_experiment"."exposure_cohort_id",
+         "posthog_experiment"."holdout_id",
+         "posthog_experiment"."start_date",
+         "posthog_experiment"."end_date",
+         "posthog_experiment"."created_at",
+         "posthog_experiment"."updated_at",
+         "posthog_experiment"."archived",
+         "posthog_experiment"."type",
+         "posthog_experiment"."variants",
+         "posthog_experiment"."metrics",
+         "posthog_experiment"."metrics_secondary"
+  FROM "posthog_experiment"
+  WHERE "posthog_experiment"."feature_flag_id" = 99999
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.48
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date"
+  FROM "posthog_survey"
+  WHERE "posthog_survey"."linked_flag_id" = 99999
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.49
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_V2_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_earlyaccessfeature"."id",
+         "posthog_earlyaccessfeature"."team_id",
+         "posthog_earlyaccessfeature"."feature_flag_id",
+         "posthog_earlyaccessfeature"."name",
+         "posthog_earlyaccessfeature"."description",
+         "posthog_earlyaccessfeature"."stage",
+         "posthog_earlyaccessfeature"."documentation_url",
+         "posthog_earlyaccessfeature"."created_at"
+  FROM "posthog_earlyaccessfeature"
+  WHERE "posthog_earlyaccessfeature"."feature_flag_id" = 99999
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.5
@@ -1572,63 +1936,161 @@
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
   FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
+  WHERE "posthog_team"."project_id" = 99999
+  ORDER BY "posthog_team"."id" ASC
+  LIMIT 1
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.50
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.51
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_V2_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_dashboard"."id",
+         "posthog_dashboard"."name",
+         "posthog_dashboard"."description",
+         "posthog_dashboard"."team_id",
+         "posthog_dashboard"."pinned",
+         "posthog_dashboard"."created_at",
+         "posthog_dashboard"."created_by_id",
+         "posthog_dashboard"."deleted",
+         "posthog_dashboard"."last_accessed_at",
+         "posthog_dashboard"."filters",
+         "posthog_dashboard"."variables",
+         "posthog_dashboard"."creation_mode",
+         "posthog_dashboard"."restriction_level",
+         "posthog_dashboard"."deprecated_tags",
+         "posthog_dashboard"."tags",
+         "posthog_dashboard"."share_token",
+         "posthog_dashboard"."is_shared"
+  FROM "posthog_dashboard"
+  INNER JOIN "posthog_featureflagdashboards" ON ("posthog_dashboard"."id" = "posthog_featureflagdashboards"."dashboard_id")
+  WHERE (NOT ("posthog_dashboard"."deleted")
+         AND "posthog_featureflagdashboards"."feature_flag_id" = 99999)
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.52
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.53
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_V2_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_dashboard"."id",
+         "posthog_dashboard"."name",
+         "posthog_dashboard"."description",
+         "posthog_dashboard"."team_id",
+         "posthog_dashboard"."pinned",
+         "posthog_dashboard"."created_at",
+         "posthog_dashboard"."created_by_id",
+         "posthog_dashboard"."deleted",
+         "posthog_dashboard"."last_accessed_at",
+         "posthog_dashboard"."filters",
+         "posthog_dashboard"."variables",
+         "posthog_dashboard"."creation_mode",
+         "posthog_dashboard"."restriction_level",
+         "posthog_dashboard"."deprecated_tags",
+         "posthog_dashboard"."tags",
+         "posthog_dashboard"."share_token",
+         "posthog_dashboard"."is_shared"
+  FROM "posthog_dashboard"
+  INNER JOIN "posthog_featureflagdashboards" ON ("posthog_dashboard"."id" = "posthog_featureflagdashboards"."dashboard_id")
+  WHERE (NOT ("posthog_dashboard"."deleted")
+         AND "posthog_featureflagdashboards"."feature_flag_id" = 99999)
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.54
   '''
-  SELECT "posthog_instancesetting"."id",
-         "posthog_instancesetting"."key",
-         "posthog_instancesetting"."raw_value"
-  FROM "posthog_instancesetting"
-  WHERE "posthog_instancesetting"."key" = 'constance:posthog:PERSON_ON_EVENTS_ENABLED'
-  ORDER BY "posthog_instancesetting"."id" ASC
-  LIMIT 1
+  SELECT "posthog_organizationmembership"."id",
+         "posthog_organizationmembership"."organization_id",
+         "posthog_organizationmembership"."user_id",
+         "posthog_organizationmembership"."level",
+         "posthog_organizationmembership"."joined_at",
+         "posthog_organizationmembership"."updated_at",
+         "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organizationmembership"
+  INNER JOIN "posthog_organization" ON ("posthog_organizationmembership"."organization_id" = "posthog_organization"."id")
+  WHERE ("posthog_organizationmembership"."organization_id" = '00000000-0000-0000-0000-000000000000'::uuid
+         AND "posthog_organizationmembership"."user_id" = 99999)
+  LIMIT 21
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.55
@@ -1779,9 +2241,10 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_featureflag"."deleted"
          AND "posthog_featureflag"."key" = 'copied-flag-key'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   ORDER BY "posthog_featureflag"."id" ASC
   LIMIT 1
   '''
@@ -2133,9 +2596,10 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
+  INNER JOIN "posthog_team" ON ("posthog_featureflag"."team_id" = "posthog_team"."id")
   WHERE ("posthog_featureflag"."deleted"
          AND "posthog_featureflag"."key" = 'copied-flag-key'
-         AND "posthog_featureflag"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   '''
 # ---
 # name: TestOrganizationFeatureFlagCopy.test_copy_feature_flag_create_new.9
diff --git a/posthog/api/test/__snapshots__/test_survey.ambr b/posthog/api/test/__snapshots__/test_survey.ambr
index a0e4260a92f6c..f4e08a30e1622 100644
--- a/posthog/api/test/__snapshots__/test_survey.ambr
+++ b/posthog/api/test/__snapshots__/test_survey.ambr
@@ -27,14 +27,859 @@
   '''
   SELECT COUNT(*) AS "__count"
   FROM "posthog_survey"
+  INNER JOIN "posthog_team" ON ("posthog_survey"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_survey"."archived"
          AND "posthog_survey"."end_date" IS NULL
          AND "posthog_survey"."start_date" IS NOT NULL
-         AND "posthog_survey"."team_id" = 99999
+         AND "posthog_team"."project_id" = 99999
          AND NOT ("posthog_survey"."type" = 'api'))
   '''
 # ---
 # name: TestSurveysAPIList.test_list_surveys.1
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.10
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.11
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.12
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.13
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.14
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.15
+  '''
+  SELECT ("posthog_survey_actions"."survey_id") AS "_prefetch_related_val_survey_id",
+         "posthog_action"."id",
+         "posthog_action"."name",
+         "posthog_action"."team_id",
+         "posthog_action"."description",
+         "posthog_action"."created_at",
+         "posthog_action"."created_by_id",
+         "posthog_action"."deleted",
+         "posthog_action"."post_to_slack",
+         "posthog_action"."slack_message_format",
+         "posthog_action"."updated_at",
+         "posthog_action"."bytecode",
+         "posthog_action"."bytecode_error",
+         "posthog_action"."steps_json",
+         "posthog_action"."pinned_at",
+         "posthog_action"."is_calculating",
+         "posthog_action"."last_calculated_at"
+  FROM "posthog_action"
+  INNER JOIN "posthog_survey_actions" ON ("posthog_action"."id" = "posthog_survey_actions"."action_id")
+  WHERE 'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid,
+                                                 '00000000-0000-0000-0000-000000000001'::uuid, /* ... */])
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.16
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.17
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.18
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.19
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.2
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.20
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.21
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.22
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.23
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.24
+  '''
+  SELECT ("posthog_survey_actions"."survey_id") AS "_prefetch_related_val_survey_id",
+         "posthog_action"."id",
+         "posthog_action"."name",
+         "posthog_action"."team_id",
+         "posthog_action"."description",
+         "posthog_action"."created_at",
+         "posthog_action"."created_by_id",
+         "posthog_action"."deleted",
+         "posthog_action"."post_to_slack",
+         "posthog_action"."slack_message_format",
+         "posthog_action"."updated_at",
+         "posthog_action"."bytecode",
+         "posthog_action"."bytecode_error",
+         "posthog_action"."steps_json",
+         "posthog_action"."pinned_at",
+         "posthog_action"."is_calculating",
+         "posthog_action"."last_calculated_at"
+  FROM "posthog_action"
+  INNER JOIN "posthog_survey_actions" ON ("posthog_action"."id" = "posthog_survey_actions"."action_id")
+  WHERE 'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid,
+                                                 '00000000-0000-0000-0000-000000000001'::uuid, /* ... */])
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.25
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.26
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.27
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -50,39 +895,663 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.28
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.29
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.30
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.31
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.32
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.33
+  '''
+  SELECT ("posthog_survey_actions"."survey_id") AS "_prefetch_related_val_survey_id",
+         "posthog_action"."id",
+         "posthog_action"."name",
+         "posthog_action"."team_id",
+         "posthog_action"."description",
+         "posthog_action"."created_at",
+         "posthog_action"."created_by_id",
+         "posthog_action"."deleted",
+         "posthog_action"."post_to_slack",
+         "posthog_action"."slack_message_format",
+         "posthog_action"."updated_at",
+         "posthog_action"."bytecode",
+         "posthog_action"."bytecode_error",
+         "posthog_action"."steps_json",
+         "posthog_action"."pinned_at",
+         "posthog_action"."is_calculating",
+         "posthog_action"."last_calculated_at"
+  FROM "posthog_action"
+  INNER JOIN "posthog_survey_actions" ON ("posthog_action"."id" = "posthog_survey_actions"."action_id")
+  WHERE 'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid,
+                                                 '00000000-0000-0000-0000-000000000001'::uuid, /* ... */])
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.34
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.35
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.36
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_survey"
+  INNER JOIN "posthog_team" ON ("posthog_survey"."team_id" = "posthog_team"."id")
+  WHERE (NOT "posthog_survey"."archived"
+         AND "posthog_survey"."end_date" IS NULL
+         AND "posthog_survey"."start_date" IS NOT NULL
+         AND "posthog_team"."project_id" = 99999
+         AND NOT ("posthog_survey"."type" = 'api'))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.37
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.38
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.39
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.4
+  '''
+  SELECT COUNT(*) AS "__count"
   FROM "posthog_featureflag"
   WHERE ("posthog_featureflag"."active"
          AND NOT "posthog_featureflag"."deleted"
          AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
-# name: TestSurveysAPIList.test_list_surveys.2
+# name: TestSurveysAPIList.test_list_surveys.40
   '''
-  SELECT "posthog_featureflag"."id",
-         "posthog_featureflag"."key",
-         "posthog_featureflag"."name",
-         "posthog_featureflag"."filters",
-         "posthog_featureflag"."rollout_percentage",
-         "posthog_featureflag"."team_id",
-         "posthog_featureflag"."created_by_id",
-         "posthog_featureflag"."created_at",
-         "posthog_featureflag"."deleted",
-         "posthog_featureflag"."active",
-         "posthog_featureflag"."rollback_conditions",
-         "posthog_featureflag"."performed_rollback",
-         "posthog_featureflag"."ensure_experience_continuity",
-         "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
+  SELECT COUNT(*) AS "__count"
   FROM "posthog_featureflag"
   WHERE ("posthog_featureflag"."active"
          AND NOT "posthog_featureflag"."deleted"
          AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
-# name: TestSurveysAPIList.test_list_surveys.3
+# name: TestSurveysAPIList.test_list_surveys.41
   '''
-  SELECT "posthog_featureflag"."id",
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
          "posthog_featureflag"."key",
          "posthog_featureflag"."name",
          "posthog_featureflag"."filters",
@@ -96,25 +1565,181 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
   '''
 # ---
-# name: TestSurveysAPIList.test_list_surveys.4
+# name: TestSurveysAPIList.test_list_surveys.42
   '''
-  SELECT COUNT(*) AS "__count"
-  FROM "posthog_survey"
-  WHERE (NOT "posthog_survey"."archived"
-         AND "posthog_survey"."end_date" IS NULL
-         AND "posthog_survey"."start_date" IS NOT NULL
-         AND "posthog_survey"."team_id" = 99999
-         AND NOT ("posthog_survey"."type" = 'api'))
+  SELECT ("posthog_survey_actions"."survey_id") AS "_prefetch_related_val_survey_id",
+         "posthog_action"."id",
+         "posthog_action"."name",
+         "posthog_action"."team_id",
+         "posthog_action"."description",
+         "posthog_action"."created_at",
+         "posthog_action"."created_by_id",
+         "posthog_action"."deleted",
+         "posthog_action"."post_to_slack",
+         "posthog_action"."slack_message_format",
+         "posthog_action"."updated_at",
+         "posthog_action"."bytecode",
+         "posthog_action"."bytecode_error",
+         "posthog_action"."steps_json",
+         "posthog_action"."pinned_at",
+         "posthog_action"."is_calculating",
+         "posthog_action"."last_calculated_at"
+  FROM "posthog_action"
+  INNER JOIN "posthog_survey_actions" ON ("posthog_action"."id" = "posthog_survey_actions"."action_id")
+  WHERE 'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid,
+                                                 '00000000-0000-0000-0000-000000000001'::uuid, /* ... */])
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.43
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
   '''
 # ---
-# name: TestSurveysAPIList.test_list_surveys.5
+# name: TestSurveysAPIList.test_list_surveys.44
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.45
   '''
   SELECT "posthog_user"."id",
          "posthog_user"."password",
@@ -146,7 +1771,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestSurveysAPIList.test_list_surveys.6
+# name: TestSurveysAPIList.test_list_surveys.46
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -209,7 +1834,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestSurveysAPIList.test_list_surveys.7
+# name: TestSurveysAPIList.test_list_surveys.47
   '''
   SELECT "posthog_survey"."id",
          "posthog_survey"."team_id",
@@ -293,7 +1918,116 @@
          AND NOT ("posthog_survey"."archived"))
   '''
 # ---
-# name: TestSurveysAPIList.test_list_surveys.8
+# name: TestSurveysAPIList.test_list_surveys.48
+  '''
+  SELECT ("posthog_survey_actions"."survey_id") AS "_prefetch_related_val_survey_id",
+         "posthog_action"."id",
+         "posthog_action"."name",
+         "posthog_action"."team_id",
+         "posthog_action"."description",
+         "posthog_action"."created_at",
+         "posthog_action"."created_by_id",
+         "posthog_action"."deleted",
+         "posthog_action"."post_to_slack",
+         "posthog_action"."slack_message_format",
+         "posthog_action"."updated_at",
+         "posthog_action"."bytecode",
+         "posthog_action"."bytecode_error",
+         "posthog_action"."steps_json",
+         "posthog_action"."pinned_at",
+         "posthog_action"."is_calculating",
+         "posthog_action"."last_calculated_at"
+  FROM "posthog_action"
+  INNER JOIN "posthog_survey_actions" ON ("posthog_action"."id" = "posthog_survey_actions"."action_id")
+  WHERE 'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid,
+                                                 '00000000-0000-0000-0000-000000000001'::uuid, /* ... */])
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.5
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.6
   '''
   SELECT ("posthog_survey_actions"."survey_id") AS "_prefetch_related_val_survey_id",
          "posthog_action"."id",
@@ -315,6 +2049,139 @@
   FROM "posthog_action"
   INNER JOIN "posthog_survey_actions" ON ("posthog_action"."id" = "posthog_survey_actions"."action_id")
   WHERE 'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid,
-                                                 '00000000-0000-0000-0000-000000000001'::uuid)
+                                                 '00000000-0000-0000-0000-000000000001'::uuid, /* ... */])
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.7
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.8
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestSurveysAPIList.test_list_surveys.9
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
diff --git a/posthog/api/test/dashboards/test_dashboard.py b/posthog/api/test/dashboards/test_dashboard.py
index ee802318db349..63f40588999d2 100644
--- a/posthog/api/test/dashboards/test_dashboard.py
+++ b/posthog/api/test/dashboards/test_dashboard.py
@@ -1313,7 +1313,7 @@ def test_create_from_template_json_can_provide_query_tile(self) -> None:
                     "effective_privilege_level": 37,
                     "effective_restriction_level": 21,
                     "favorited": False,
-                    "filters": {"filter_test_accounts": True},
+                    "filters": {},
                     "filters_hash": ANY,
                     "hasMore": None,
                     "id": ANY,
diff --git a/posthog/api/test/test_authentication.py b/posthog/api/test/test_authentication.py
index 7a50685c880ef..9323f66087813 100644
--- a/posthog/api/test/test_authentication.py
+++ b/posthog/api/test/test_authentication.py
@@ -12,6 +12,7 @@
 from rest_framework import status
 from social_django.models import UserSocialAuth
 from two_factor.utils import totp_digits
+import time
 
 from posthog.api.authentication import password_reset_token_generator
 from posthog.models import User
@@ -21,6 +22,7 @@
 from posthog.models.personal_api_key import PersonalAPIKey, hash_key_value
 from posthog.models.utils import generate_random_token_personal
 from posthog.test.base import APIBaseTest
+from django_otp.plugins.otp_static.models import StaticDevice
 
 VALID_TEST_PASSWORD = "mighty-strong-secure-1337!!"
 
@@ -243,6 +245,14 @@ def test_login_endpoint_is_protected_against_brute_force_attempts(self):
                 },
             )
 
+
+class TestTwoFactorAPI(APIBaseTest):
+    """
+    Tests the two factor view set.
+    """
+
+    CONFIG_AUTO_LOGIN = False
+
     def test_login_2fa_enabled(self):
         device = self.user.totpdevice_set.create(name="default", key=random_hex(), digits=6)  # type: ignore
 
@@ -322,6 +332,76 @@ def test_2fa_throttling(self):
             "2fa_too_many_attempts",
         )
 
+    def test_login_with_backup_code(self):
+        """Test that a user can log in using a backup code instead of TOTP"""
+        self.user.totpdevice_set.create(name="default", key=random_hex(), digits=6)  # type: ignore
+        static_device = StaticDevice.objects.create(user=self.user, name="backup")
+        static_device.token_set.create(token="123456")
+
+        # First authenticate with username/password
+        response = self.client.post("/api/login", {"email": self.CONFIG_EMAIL, "password": self.CONFIG_PASSWORD})
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+        self.assertEqual(response.json()["code"], "2fa_required")
+
+        # Then authenticate with backup code
+        response = self.client.post("/api/login/token", {"token": "123456"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Verify we're logged in
+        response = self.client.get("/api/users/@me/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.json()["email"], self.user.email)
+
+        # Verify the backup code was consumed (can't be reused)
+        self.assertFalse(static_device.token_set.filter(token="123456").exists())
+
+    def test_backup_code_is_consumed_after_use(self):
+        """Test that backup codes are one-time use only"""
+        self.user.totpdevice_set.create(name="default", key=random_hex(), digits=6)  # type: ignore
+        static_device = StaticDevice.objects.create(user=self.user, name="backup")
+        static_device.token_set.create(token="123456")
+
+        # First authenticate with username/password
+        self.client.post("/api/login", {"email": self.CONFIG_EMAIL, "password": self.CONFIG_PASSWORD})
+
+        # Use backup code once
+        response = self.client.post("/api/login/token", {"token": "123456"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Log out
+        self.client.logout()
+
+        # Wait for throttling to expire
+        time.sleep(2)
+
+        # Try to authenticate again with same backup code
+        self.client.post("/api/login", {"email": self.CONFIG_EMAIL, "password": self.CONFIG_PASSWORD})
+        response = self.client.post("/api/login/token", {"token": "123456"})
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(response.json()["code"], "2fa_invalid")
+
+    def test_backup_codes_work_when_totp_device_is_throttled(self):
+        """Test that backup codes still work even if TOTP device is throttled"""
+        self.user.totpdevice_set.create(name="default", key=random_hex(), digits=6)  # type: ignore
+        static_device = StaticDevice.objects.create(user=self.user, name="backup")
+        static_device.token_set.create(token="123456")
+
+        # First authenticate with username/password
+        self.client.post("/api/login", {"email": self.CONFIG_EMAIL, "password": self.CONFIG_PASSWORD})
+
+        # Trigger TOTP throttling with invalid attempts
+        self.client.post("/api/login/token", {"token": "000000"})
+        self.client.post("/api/login/token", {"token": "000000"})
+
+        # Wait for throttling to expire
+        import time
+
+        time.sleep(2)
+
+        # Backup code should still work
+        response = self.client.post("/api/login/token", {"token": "123456"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
 
 class TestPasswordResetAPI(APIBaseTest):
     CONFIG_AUTO_LOGIN = False
diff --git a/posthog/api/test/test_cohort.py b/posthog/api/test/test_cohort.py
index 5e16d6b7bc519..8a32a8b9a5dd0 100644
--- a/posthog/api/test/test_cohort.py
+++ b/posthog/api/test/test_cohort.py
@@ -1111,7 +1111,7 @@ def _calc(query: str) -> int:
         self.assertEqual(1, _calc("select 1 from events"))
 
         # raises on all other cases
-        response = self.client.post(
+        query_post_response = self.client.post(
             f"/api/projects/{self.team.id}/cohorts",
             data={
                 "name": "cohort A",
@@ -1122,7 +1122,15 @@ def _calc(query: str) -> int:
                 },
             },
         )
-        self.assertEqual(response.status_code, 500, response.content)
+        query_get_response = self.client.get(
+            f"/api/projects/{self.team.id}/cohorts/{query_post_response.json()['id']}/"
+        )
+
+        self.assertEqual(query_post_response.status_code, 201)
+        self.assertEqual(query_get_response.status_code, 200)
+        self.assertEqual(
+            query_get_response.json()["errors_calculating"], 1
+        )  # Should be because selecting from groups is not allowed
 
     @patch("posthog.api.cohort.report_user_action")
     def test_cohort_with_is_set_filter_missing_value(self, patch_capture):
diff --git a/posthog/api/test/test_decide.py b/posthog/api/test/test_decide.py
index 5af8e61dc3068..bbf74ee1ecb72 100644
--- a/posthog/api/test/test_decide.py
+++ b/posthog/api/test/test_decide.py
@@ -5,6 +5,7 @@
 from typing import Optional
 from unittest.mock import patch, Mock
 
+from inline_snapshot import snapshot
 import pytest
 from django.conf import settings
 from django.core.cache import cache
@@ -38,11 +39,11 @@
 from posthog.models.cohort.cohort import Cohort
 from posthog.models.feature_flag.feature_flag import FeatureFlagHashKeyOverride
 from posthog.models.group.group import Group
-from posthog.models.hog_functions.hog_function import HogFunction
 from posthog.models.organization import Organization, OrganizationMembership
 from posthog.models.person import PersonDistinctId
 from posthog.models.personal_api_key import hash_key_value
 from posthog.models.plugin import sync_team_inject_web_apps
+from posthog.models.remote_config import RemoteConfig
 from posthog.models.team.team import Team
 from posthog.models.user import User
 from posthog.models.utils import generate_random_token_personal
@@ -74,6 +75,9 @@ def make_session_recording_decide_response(overrides: Optional[dict] = None) ->
     }
 
 
+# TODO: Add a derived version of decide that covers the new RemoteConfig option
+
+
 @patch(
     "posthog.models.feature_flag.flag_matching.postgres_healthcheck.is_connected",
     return_value=True,
@@ -84,6 +88,8 @@ class TestDecide(BaseTest, QueryMatchingTest):
     We use Django's base test class instead of DRF's because we need granular control over the Content-Type sent over.
     """
 
+    use_remote_config = False
+
     def setUp(self, *args):
         cache.clear()
 
@@ -111,27 +117,49 @@ def _post_decide(
         ip="127.0.0.1",
         disable_flags=False,
         user_agent: Optional[str] = None,
+        assert_num_queries: Optional[int] = None,
+        simulate_database_timeout: bool = False,
     ):
+        if self.use_remote_config:
+            # We test a lot with settings changes so the idea is to refresh the remote config
+            remote_config = RemoteConfig.objects.get(team=self.team)
+            remote_config.sync()
+
         if groups is None:
             groups = {}
-        return self.client.post(
-            f"/decide/?v={api_version}",
-            {
-                "data": self._dict_to_b64(
-                    data
-                    or {
-                        "token": self.team.api_token,
-                        "distinct_id": distinct_id,
-                        "groups": groups,
-                        "geoip_disable": geoip_disable,
-                        "disable_flags": disable_flags,
-                    },
-                )
-            },
-            HTTP_ORIGIN=origin,
-            REMOTE_ADDR=ip,
-            HTTP_USER_AGENT=user_agent or "PostHog test",
-        )
+
+        def do_request():
+            url = f"/decide/?v={api_version}"
+            if self.use_remote_config:
+                url += "&use_remote_config=true"
+            return self.client.post(
+                url,
+                {
+                    "data": self._dict_to_b64(
+                        data
+                        or {
+                            "token": self.team.api_token,
+                            "distinct_id": distinct_id,
+                            "groups": groups,
+                            "geoip_disable": geoip_disable,
+                            "disable_flags": disable_flags,
+                        },
+                    )
+                },
+                HTTP_ORIGIN=origin,
+                REMOTE_ADDR=ip,
+                HTTP_USER_AGENT=user_agent or "PostHog test",
+            )
+
+        if simulate_database_timeout:
+            with connection.execute_wrapper(QueryTimeoutWrapper()):
+                return do_request()
+
+        if assert_num_queries:
+            with self.assertNumQueries(assert_num_queries):
+                return do_request()
+        else:
+            return do_request()
 
     def _update_team(self, data, expected_status_code: int = status.HTTP_200_OK):
         # use a non-csrf client to make requests
@@ -545,7 +573,7 @@ def test_web_vitals_autocapture_allowed_metrics(self, *args):
             {"web_vitals": True, "network_timing": True, "web_vitals_allowed_metrics": ["CLS", "FCP"]},
         )
 
-    def test_user_session_recording_opt_in_wildcard_domain(self, *args):
+    def test_user_session_recording_domain_opt_in_wildcard(self, *args):
         # :TRICKY: Test for regression around caching
         response = self._post_decide().json()
         self.assertEqual(response["sessionRecording"], False)
@@ -565,7 +593,7 @@ def test_user_session_recording_opt_in_wildcard_domain(self, *args):
         response = self._post_decide(origin="https://random.example.com.evilsite.com").json()
         self.assertEqual(response["sessionRecording"], False)
 
-    def test_user_session_recording_evil_site(self, *args):
+    def test_user_session_recording_domain_not_allowed(self, *args):
         self._update_team(
             {
                 "session_recording_opt_in": True,
@@ -640,9 +668,8 @@ def test_user_session_recording_allowed_when_permitted_domains_are_not_http_base
 
     @snapshot_postgres_queries
     def test_web_app_queries(self, *args):
-        with self.assertNumQueries(2):
-            response = self._post_decide()
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
+        response = self._post_decide(assert_num_queries=2)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
 
         plugin = Plugin.objects.create(organization=self.team.organization, name="My Plugin", plugin_type="source")
         PluginSourceFile.objects.create(
@@ -664,11 +691,10 @@ def test_web_app_queries(self, *args):
 
         # caching flag definitions in the above mean fewer queries
         # 3 of these queries are just for setting transaction scope
-        with self.assertNumQueries(8):
-            response = self._post_decide()
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            injected = response.json()["siteApps"]
-            self.assertEqual(len(injected), 1)
+        response = self._post_decide(assert_num_queries=0 if self.use_remote_config else 4)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        injected = response.json()["siteApps"]
+        self.assertEqual(len(injected), 1)
 
     def test_site_app_injection(self, *args):
         plugin = Plugin.objects.create(organization=self.team.organization, name="My Plugin", plugin_type="source")
@@ -689,51 +715,11 @@ def test_site_app_injection(self, *args):
         )
         self.team.refresh_from_db()
         self.assertTrue(self.team.inject_web_apps)
-        with self.assertNumQueries(9):
-            response = self._post_decide()
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            injected = response.json()["siteApps"]
-            self.assertEqual(len(injected), 1)
-            self.assertTrue(injected[0]["url"].startswith(f"/site_app/{plugin_config.id}/{plugin_config.web_token}/"))
-
-    def test_site_function_injection(self, *args):
-        # yype: site_app
-        site_app = HogFunction.objects.create(
-            team=self.team,
-            name="my_function",
-            hog="function onLoad(){}",
-            type="site_app",
-            transpiled="function onLoad(){}",
-            enabled=True,
-        )
-
-        self.team.refresh_from_db()
-        self.assertTrue(self.team.inject_web_apps)
-        with self.assertNumQueries(9):
-            response = self._post_decide()
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            injected = response.json()["siteApps"]
-            self.assertEqual(len(injected), 1)
-            self.assertTrue(injected[0]["url"].startswith(f"/site_function/{site_app.id}/"))
-
-        # yype: site_destination
-        site_destination = HogFunction.objects.create(
-            team=self.team,
-            name="my_function",
-            hog="function onLoad(){}",
-            type="site_destination",
-            transpiled="function onLoad(){}",
-            enabled=True,
-        )
-
-        self.team.refresh_from_db()
-        self.assertTrue(self.team.inject_web_apps)
-        with self.assertNumQueries(8):
-            response = self._post_decide()
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            injected = response.json()["siteApps"]
-            self.assertEqual(len(injected), 2)
-            self.assertTrue(injected[1]["url"].startswith(f"/site_function/{site_destination.id}/"))
+        response = self._post_decide(assert_num_queries=1 if self.use_remote_config else 5)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        injected = response.json()["siteApps"]
+        self.assertEqual(len(injected), 1)
+        self.assertTrue(injected[0]["url"].startswith(f"/site_app/{plugin_config.id}/{plugin_config.web_token}/"))
 
     def test_feature_flags(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -788,17 +774,15 @@ def test_feature_flags(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(4):
-            response = self._post_decide()
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
+        response = self._post_decide(assert_num_queries=4)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertIn("default-flag", response.json()["featureFlags"])
         self.assertIn("beta-feature", response.json()["featureFlags"])
         self.assertIn("filer-by-property-2", response.json()["featureFlags"])
 
         # caching flag definitions in the above query mean fewer queries
-        with self.assertNumQueries(4):
-            response = self._post_decide({"token": self.team.api_token, "distinct_id": "another_id"})
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
+        response = self._post_decide({"token": self.team.api_token, "distinct_id": "another_id"}, assert_num_queries=4)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.json()["featureFlags"], ["default-flag"])
 
     def test_feature_flags_v3_json(self, *args):
@@ -833,9 +817,8 @@ def test_feature_flags_v3_json(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
+        response = self._post_decide(api_version=3, assert_num_queries=4)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
 
         self.assertEqual(
             {"color": "blue"},
@@ -896,20 +879,18 @@ def test_feature_flags_v3_json_multivariate(self, *args):
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=2)
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertIn("beta-feature", response.json()["featureFlags"])
-            self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
+        response = self._post_decide(api_version=2, assert_num_queries=0)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn("beta-feature", response.json()["featureFlags"])
+        self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
-            self.assertEqual(
-                {"color": "blue"},
-                response.json()["featureFlagPayloads"]["multivariate-flag"],
-            )
+        response = self._post_decide(api_version=3, assert_num_queries=0)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
+        self.assertEqual(
+            {"color": "blue"},
+            response.json()["featureFlagPayloads"]["multivariate-flag"],
+        )
 
     def test_feature_flags_v2(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -963,28 +944,25 @@ def test_feature_flags_v2(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=1)  # v1 functionality should not break
-            self.assertEqual(response.status_code, status.HTTP_200_OK)
-            self.assertIn("beta-feature", response.json()["featureFlags"])
-            self.assertIn("default-flag", response.json()["featureFlags"])
+        response = self._post_decide(api_version=1, assert_num_queries=0)  # v1 functionality should not break
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn("beta-feature", response.json()["featureFlags"])
+        self.assertIn("default-flag", response.json()["featureFlags"])
 
         # caching flag definitions in the above query mean fewer queries
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=2)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
+        response = self._post_decide(api_version=2, assert_num_queries=0)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=2, distinct_id="other_id")
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "third-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, different variant assigned
+        response = self._post_decide(api_version=2, distinct_id="other_id", assert_num_queries=0)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "third-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, different variant assigned
 
     def test_feature_flags_v2_with_property_overrides(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1060,16 +1038,14 @@ def test_feature_flags_v2_with_property_overrides(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=2, ip=australia_ip)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
+        response = self._post_decide(api_version=2, ip=australia_ip, assert_num_queries=0)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
 
         # caching flag definitions in the above mean fewer queries
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=2, distinct_id="other_id", ip=australia_ip)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
+        response = self._post_decide(api_version=2, distinct_id="other_id", ip=australia_ip, assert_num_queries=0)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
 
     def test_feature_flags_v2_with_geoip_error(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1144,16 +1120,13 @@ def test_feature_flags_v2_with_geoip_error(self, *args):
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(4):
-            # One to compute properties for all flags
-            response = self._post_decide(api_version=2, distinct_id="example_id")
-            self.assertTrue("beta-feature" not in response.json()["featureFlags"])
-            self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
+        response = self._post_decide(api_version=2, distinct_id="example_id", assert_num_queries=4)
+        self.assertTrue("beta-feature" not in response.json()["featureFlags"])
+        self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id="other_id")
-            self.assertTrue("beta-feature" not in response.json()["featureFlags"])
-            self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
+        response = self._post_decide(api_version=2, distinct_id="other_id", assert_num_queries=4)
+        self.assertTrue("beta-feature" not in response.json()["featureFlags"])
+        self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
 
     def test_feature_flags_v2_consistent_flags(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1210,33 +1183,32 @@ def test_feature_flags_v2_consistent_flags(self, *args):
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(5):
-            response = self._post_decide(api_version=2)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
+        response = self._post_decide(api_version=2, assert_num_queries=5)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
 
         # new person, merged from old distinct ID
         # person.delete()
         # person2 = Person.objects.create(team=self.team, distinct_ids=["example_id", "other_id"], properties={"email": "tim@posthog.com"})
         person.add_distinct_id("other_id")
 
-        with self.assertNumQueries(13):
-            response = self._post_decide(
-                api_version=2,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": "other_id",
-                    "$anon_distinct_id": "example_id",
-                },
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, overridden by distinct_id, same variant assigned
+        response = self._post_decide(
+            api_version=2,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": "other_id",
+                "$anon_distinct_id": "example_id",
+            },
+            assert_num_queries=13,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, overridden by distinct_id, same variant assigned
 
     def test_feature_flags_v3_consistent_flags_with_numeric_distinct_ids(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1270,46 +1242,45 @@ def test_feature_flags_v3_consistent_flags_with_numeric_distinct_ids(self, *args
         )  # Should be enabled for everyone
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(5):
-            response = self._post_decide(api_version=2)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        response = self._post_decide(api_version=2, assert_num_queries=5)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
 
-        with self.assertNumQueries(13):
-            response = self._post_decide(
-                api_version=2,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": 12345,
-                    "$anon_distinct_id": "example_id",
-                },
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        response = self._post_decide(
+            api_version=2,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": 12345,
+                "$anon_distinct_id": "example_id",
+            },
+            assert_num_queries=13,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
 
-        with self.assertNumQueries(9):
-            response = self._post_decide(
-                api_version=2,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": "xyz",
-                    "$anon_distinct_id": 12345,
-                },
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        response = self._post_decide(
+            api_version=2,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": "xyz",
+                "$anon_distinct_id": 12345,
+            },
+            assert_num_queries=9,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
 
-        with self.assertNumQueries(9):
-            response = self._post_decide(
-                api_version=2,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": 5,
-                    "$anon_distinct_id": 12345,
-                },
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        response = self._post_decide(
+            api_version=2,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": 5,
+                "$anon_distinct_id": 12345,
+            },
+            assert_num_queries=9,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
 
     def test_feature_flags_v2_consistent_flags_with_ingestion_delays(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1364,31 +1335,30 @@ def test_feature_flags_v2_consistent_flags_with_ingestion_delays(self, *args):
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
+        response = self._post_decide(api_version=2, assert_num_queries=4)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
 
         # identify event is sent, but again, ingestion delays, so no entry in personDistinctID table
         # person.add_distinct_id("other_id")
         # in which case, we're pretty much trashed
-        with self.assertNumQueries(12):
-            response = self._post_decide(
-                api_version=2,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": "other_id",
-                    "$anon_distinct_id": "example_id",
-                },
-            )
-            # self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "third-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, should've been overridden by distinct_id, but ingestion delays mean different variant assigned
+        response = self._post_decide(
+            api_version=2,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": "other_id",
+                "$anon_distinct_id": "example_id",
+            },
+            assert_num_queries=12,
+        )
+        # self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "third-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, should've been overridden by distinct_id, but ingestion delays mean different variant assigned
 
     def test_feature_flags_v2_consistent_flags_with_merged_persons(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1445,13 +1415,12 @@ def test_feature_flags_v2_consistent_flags_with_merged_persons(self, *args):
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(5):
-            response = self._post_decide(api_version=2)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
+        response = self._post_decide(api_version=2, assert_num_queries=5)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
 
         # new person, created separately before "example_id" came into the picture.
         # on identify, this will trigger a merge with person.id being deleted, and
@@ -1463,20 +1432,20 @@ def test_feature_flags_v2_consistent_flags_with_merged_persons(self, *args):
         )
 
         # caching flag definitions in the above mean fewer queries
-        with self.assertNumQueries(13):
-            response = self._post_decide(
-                api_version=2,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": "other_id",
-                    "$anon_distinct_id": "example_id",
-                },
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, overridden by distinct_id, same variant assigned
+        response = self._post_decide(
+            api_version=2,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": "other_id",
+                "$anon_distinct_id": "example_id",
+            },
+            assert_num_queries=13,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, overridden by distinct_id, same variant assigned
 
         # now let's say a merge happens with a call like: identify(distinct_id='example_id', anon_distinct_id='other_id')
         # that is, person2 is going to get merged into person. (Could've been vice versa, but the following code assumes this, it's symmetric.)
@@ -1502,16 +1471,16 @@ def test_feature_flags_v2_consistent_flags_with_merged_persons(self, *args):
         person.add_distinct_id("other_id")
 
         # caching flag definitions in the above mean fewer queries
-        with self.assertNumQueries(5):
-            response = self._post_decide(
-                api_version=2,
-                data={"token": self.team.api_token, "distinct_id": "other_id"},
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, overridden by distinct_id, same variant assigned
+        response = self._post_decide(
+            api_version=2,
+            data={"token": self.team.api_token, "distinct_id": "other_id"},
+            assert_num_queries=5,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, overridden by distinct_id, same variant assigned
 
     def test_feature_flags_v2_consistent_flags_with_delayed_new_identified_person(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1568,32 +1537,30 @@ def test_feature_flags_v2_consistent_flags_with_delayed_new_identified_person(se
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(5):
-            response = self._post_decide(api_version=2)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
+        response = self._post_decide(api_version=2, assert_num_queries=5)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
 
         # new person with "other_id" is yet to be created
 
         # caching flag definitions in the above mean fewer queries
-        with self.assertNumQueries(13):
-            # one extra query to find person_id for $anon_distinct_id
-            response = self._post_decide(
-                api_version=2,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": "other_id",
-                    "$anon_distinct_id": "example_id",
-                },
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, overridden by distinct_id, same variant assigned
+        response = self._post_decide(
+            api_version=2,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": "other_id",
+                "$anon_distinct_id": "example_id",
+            },
+            assert_num_queries=13,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, overridden by distinct_id, same variant assigned
 
         # calling a simple decide call, while 'other_id' is still missing a person creation.
         # In this case, we are over our grace period for ingestion, and there's
@@ -1601,31 +1568,29 @@ def test_feature_flags_v2_consistent_flags_with_delayed_new_identified_person(se
         # So, things appear like a completely new person with distinct-id = other_id.
         # And this person can't have any hash key overrides (since the person doesn't yet exist)
         # So one fewer query to not get overrides.
-        with self.assertNumQueries(4):
-            # caching flag definitions in the above mean fewer queries
-
-            response = self._post_decide(
-                api_version=2,
-                data={"token": self.team.api_token, "distinct_id": "other_id"},
-            )
-            # self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual("third-variant", response.json()["featureFlags"]["multivariate-flag"])  # variant changed
+        response = self._post_decide(
+            api_version=2,
+            data={"token": self.team.api_token, "distinct_id": "other_id"},
+            assert_num_queries=4,
+        )
+        # self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual("third-variant", response.json()["featureFlags"]["multivariate-flag"])  # variant changed
 
         person.add_distinct_id("other_id")
         # Finally, 'other_id' is merged. The result goes back to its overridden values
 
         # caching flag definitions in the above mean fewer queries
-        with self.assertNumQueries(5):
-            response = self._post_decide(
-                api_version=2,
-                data={"token": self.team.api_token, "distinct_id": "other_id"},
-            )
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, overridden by distinct_id, same variant assigned
+        response = self._post_decide(
+            api_version=2,
+            data={"token": self.team.api_token, "distinct_id": "other_id"},
+            assert_num_queries=5,
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, overridden by distinct_id, same variant assigned
 
     def test_feature_flags_v2_complex(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1688,30 +1653,26 @@ def test_feature_flags_v2_complex(self, *args):
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id="hosted_id")
-            self.assertIsNone(
-                (response.json()["featureFlags"]).get("multivariate-flag", None)
-            )  # User is does not have realm == "cloud". Value is None.
-            self.assertTrue(
-                (response.json()["featureFlags"]).get("default-flag")
-            )  # User still receives the default flag
-
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id="example_id")
-            self.assertIsNotNone(
-                response.json()["featureFlags"]["multivariate-flag"]
-            )  # User has an 80% chance of being assigned any non-empty value.
-            self.assertEqual(
-                "second-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # If the user falls in the rollout group, they have a 25% chance of being assigned any particular variant.
-            # Their overall probability is therefore 80% * 25% = 20%.
-            # To give another example, if n = 100 Cloud users and rollout_percentage = 80:
-            # None:           20 (100 * (100% - 80%))
-            # first-variant:  20 (100 * 80% * 25% = 20 users)
-            # second-variant: 20 (100 * 80% * 25% = 20 users)
-            # third-variant:  20 (100 * 80% * 25% = 20 users)
-            # fourth-variant: 20 (100 * 80% * 25% = 20 users)
+        response = self._post_decide(api_version=2, distinct_id="hosted_id", assert_num_queries=4)
+        self.assertIsNone(
+            (response.json()["featureFlags"]).get("multivariate-flag", None)
+        )  # User is does not have realm == "cloud". Value is None.
+        self.assertTrue((response.json()["featureFlags"]).get("default-flag"))  # User still receives the default flag
+
+        response = self._post_decide(api_version=2, distinct_id="example_id", assert_num_queries=4)
+        self.assertIsNotNone(
+            response.json()["featureFlags"]["multivariate-flag"]
+        )  # User has an 80% chance of being assigned any non-empty value.
+        self.assertEqual(
+            "second-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # If the user falls in the rollout group, they have a 25% chance of being assigned any particular variant.
+        # Their overall probability is therefore 80% * 25% = 20%.
+        # To give another example, if n = 100 Cloud users and rollout_percentage = 80:
+        # None:           20 (100 * (100% - 80%))
+        # first-variant:  20 (100 * 80% * 25% = 20 users)
+        # second-variant: 20 (100 * 80% * 25% = 20 users)
+        # third-variant:  20 (100 * 80% * 25% = 20 users)
+        # fourth-variant: 20 (100 * 80% * 25% = 20 users)
 
     def test_feature_flags_v3(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -1790,23 +1751,21 @@ def test_feature_flags_v3(self, *args):
         self._post_decide(api_version=3)
         client.logout()
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=3)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
-            self.assertFalse(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(api_version=3, assert_num_queries=0)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
+        self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=3, distinct_id="other_id")
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "third-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # different hash, different variant assigned
-            self.assertFalse(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(api_version=3, distinct_id="other_id", assert_num_queries=0)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "third-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # different hash, different variant assigned
+        self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
     @patch("posthog.models.feature_flag.flag_matching.FLAG_EVALUATION_ERROR_COUNTER")
     def test_feature_flags_v3_with_database_errors(self, mock_counter, *args):
@@ -1901,24 +1860,22 @@ def test_feature_flags_v3_with_database_errors(self, mock_counter, *args):
 
         client.logout()
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=3)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
-            self.assertFalse(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(api_version=3, assert_num_queries=4)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
+        self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
         # now database is down
-        with connection.execute_wrapper(QueryTimeoutWrapper()):
-            response = self._post_decide(api_version=3, distinct_id="example_id")
-            self.assertTrue("beta-feature" not in response.json()["featureFlags"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
-            self.assertTrue(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(api_version=3, distinct_id="example_id", simulate_database_timeout=True)
+        self.assertTrue("beta-feature" not in response.json()["featureFlags"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual("first-variant", response.json()["featureFlags"]["multivariate-flag"])
+        self.assertTrue(response.json()["errorsWhileComputingFlags"])
 
-            mock_counter.labels.assert_called_once_with(reason="timeout")
+        mock_counter.labels.assert_called_once_with(reason="timeout")
 
     @patch("posthog.models.feature_flag.flag_matching.FLAG_HASH_KEY_WRITES_COUNTER")
     @patch("posthog.api.decide.FLAG_EVALUATION_COUNTER")
@@ -2035,15 +1992,14 @@ def test_feature_flags_v3_metric_counter(self, mock_error_counter, mock_counter,
             mock_counter.reset_mock()
             mock_hash_key_counter.reset_mock()
 
-            with self.assertNumQueries(9):
-                response = self._post_decide(api_version=3)
-                self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-                self.assertTrue(response.json()["featureFlags"]["default-flag"])
-                self.assertEqual(
-                    "first-variant",
-                    response.json()["featureFlags"]["multivariate-flag"],
-                )  # assigned by distinct_id hash
-                self.assertFalse(response.json()["errorsWhileComputingFlags"])
+            response = self._post_decide(api_version=3, assert_num_queries=9)
+            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+            self.assertTrue(response.json()["featureFlags"]["default-flag"])
+            self.assertEqual(
+                "first-variant",
+                response.json()["featureFlags"]["multivariate-flag"],
+            )  # assigned by distinct_id hash
+            self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
             mock_counter.labels.assert_called_once_with(
                 team_id=str(self.team.pk),
@@ -2057,24 +2013,23 @@ def test_feature_flags_v3_metric_counter(self, mock_error_counter, mock_counter,
             mock_counter.reset_mock()
 
             # now database is down
-            with connection.execute_wrapper(QueryTimeoutWrapper()):
-                response = self._post_decide(api_version=3, distinct_id="example_id")
-                self.assertTrue("beta-feature" not in response.json()["featureFlags"])
-                self.assertTrue(response.json()["featureFlags"]["default-flag"])
-                self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
-                self.assertTrue(response.json()["errorsWhileComputingFlags"])
-
-                mock_counter.labels.assert_called_once_with(
-                    team_id=str(self.team.pk),
-                    errors_computing=True,
-                    has_hash_key_override=False,
-                )
-                mock_counter.labels.return_value.inc.assert_called_once()
-                mock_error_counter.labels.assert_any_call(reason="healthcheck_failed")
-                mock_error_counter.labels.assert_any_call(reason="timeout")
-                self.assertEqual(mock_error_counter.labels.call_count, 2)
+            response = self._post_decide(api_version=3, distinct_id="example_id", simulate_database_timeout=True)
+            self.assertTrue("beta-feature" not in response.json()["featureFlags"])
+            self.assertTrue(response.json()["featureFlags"]["default-flag"])
+            self.assertTrue("multivariate-flag" not in response.json()["featureFlags"])
+            self.assertTrue(response.json()["errorsWhileComputingFlags"])
 
-                mock_hash_key_counter.labels.assert_not_called()
+            mock_counter.labels.assert_called_once_with(
+                team_id=str(self.team.pk),
+                errors_computing=True,
+                has_hash_key_override=False,
+            )
+            mock_counter.labels.return_value.inc.assert_called_once()
+            mock_error_counter.labels.assert_any_call(reason="healthcheck_failed")
+            mock_error_counter.labels.assert_any_call(reason="timeout")
+            self.assertEqual(mock_error_counter.labels.call_count, 2)
+
+            mock_hash_key_counter.labels.assert_not_called()
 
     def test_feature_flags_v3_with_database_errors_and_no_flags(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -2090,16 +2045,13 @@ def test_feature_flags_v3_with_database_errors_and_no_flags(self, *args):
         # adding team to cache
         self._post_decide(api_version=3)
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.json()["featureFlags"], {})
-            self.assertFalse(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(api_version=3, assert_num_queries=0)
+        self.assertEqual(response.json()["featureFlags"], {})
+        self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
-        # now database is down
-        with connection.execute_wrapper(QueryTimeoutWrapper()):
-            response = self._post_decide(api_version=3, distinct_id="example_id")
-            self.assertEqual(response.json()["featureFlags"], {})
-            self.assertFalse(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(api_version=3, distinct_id="example_id", simulate_database_timeout=True)
+        self.assertEqual(response.json()["featureFlags"], {})
+        self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
     def test_feature_flags_v3_with_database_errors_and_geoip_properties(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -2159,18 +2111,17 @@ def test_feature_flags_v3_with_database_errors_and_geoip_properties(self, *args)
 
         client.logout()
 
-        with self.assertNumQueries(0):
-            response = self._post_decide(api_version=3, ip=australia_ip)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertFalse(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(api_version=3, ip=australia_ip, assert_num_queries=0)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
-        # now database is down
-        with connection.execute_wrapper(QueryTimeoutWrapper()):
-            response = self._post_decide(api_version=3, distinct_id="example_id", ip=australia_ip)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertFalse(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(
+            api_version=3, distinct_id="example_id", ip=australia_ip, simulate_database_timeout=True
+        )
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertFalse(response.json()["errorsWhileComputingFlags"])
 
     def test_feature_flags_v3_consistent_flags_with_database_errors(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -2228,38 +2179,37 @@ def test_feature_flags_v3_consistent_flags_with_database_errors(self, *args):
         # make sure caches are populated
         response = self._post_decide(api_version=3)
 
-        with self.assertNumQueries(5):
-            # effectively 3 queries, wrapped around by an atomic transaction
-            # E   1. SAVEPOINT "s4379526528_x103"
-            # E   2. SET LOCAL statement_timeout = 1000
-            # E   3. SELECT "posthog_persondistinctid"."person_id", "posthog_persondistinctid"."distinct_id" FROM "posthog_persondistinctid"
-            #           WHERE ("posthog_persondistinctid"."distinct_id" IN ('example_id') AND "posthog_persondistinctid"."team_id" = 1)
-            # E   4. SELECT "posthog_featureflaghashkeyoverride"."feature_flag_key", "posthog_featureflaghashkeyoverride"."hash_key", "posthog_featureflaghashkeyoverride"."person_id" FROM "posthog_featureflaghashkeyoverride"
-            #            WHERE ("posthog_featureflaghashkeyoverride"."person_id" IN (7) AND "posthog_featureflaghashkeyoverride"."team_id" = 1)
-            # E   5. RELEASE SAVEPOINT "s4379526528_x103"
-            response = self._post_decide(api_version=3)
-            self.assertTrue(response.json()["featureFlags"]["beta-feature"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertEqual(
-                "first-variant", response.json()["featureFlags"]["multivariate-flag"]
-            )  # assigned by distinct_id hash
+        # effectively 3 queries, wrapped around by an atomic transaction
+        # E   1. SAVEPOINT "s4379526528_x103"
+        # E   2. SET LOCAL statement_timeout = 1000
+        # E   3. SELECT "posthog_persondistinctid"."person_id", "posthog_persondistinctid"."distinct_id" FROM "posthog_persondistinctid"
+        #           WHERE ("posthog_persondistinctid"."distinct_id" IN ('example_id') AND "posthog_persondistinctid"."team_id" = 1)
+        # E   4. SELECT "posthog_featureflaghashkeyoverride"."feature_flag_key", "posthog_featureflaghashkeyoverride"."hash_key", "posthog_featureflaghashkeyoverride"."person_id" FROM "posthog_featureflaghashkeyoverride"
+        #            WHERE ("posthog_featureflaghashkeyoverride"."person_id" IN (7) AND "posthog_featureflaghashkeyoverride"."team_id" = 1)
+        # E   5. RELEASE SAVEPOINT "s4379526528_x103"
+        response = self._post_decide(api_version=3, assert_num_queries=5)
+        self.assertTrue(response.json()["featureFlags"]["beta-feature"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertEqual(
+            "first-variant", response.json()["featureFlags"]["multivariate-flag"]
+        )  # assigned by distinct_id hash
 
         # new person, merged from old distinct ID
         person.add_distinct_id("other_id")
 
         # now database is down
-        with connection.execute_wrapper(QueryTimeoutWrapper()):
-            response = self._post_decide(
-                api_version=3,
-                data={
-                    "token": self.team.api_token,
-                    "distinct_id": "other_id",
-                    "$anon_distinct_id": "example_id",
-                },
-            )
-            self.assertTrue("beta-feature" not in response.json()["featureFlags"])
-            self.assertTrue(response.json()["featureFlags"]["default-flag"])
-            self.assertTrue(response.json()["errorsWhileComputingFlags"])
+        response = self._post_decide(
+            api_version=3,
+            data={
+                "token": self.team.api_token,
+                "distinct_id": "other_id",
+                "$anon_distinct_id": "example_id",
+            },
+            simulate_database_timeout=True,
+        )
+        self.assertTrue("beta-feature" not in response.json()["featureFlags"])
+        self.assertTrue(response.json()["featureFlags"]["default-flag"])
+        self.assertTrue(response.json()["errorsWhileComputingFlags"])
 
     def test_feature_flags_v2_with_groups(self, *args):
         # More in-depth tests in posthog/api/test/test_feature_flag.py
@@ -2287,13 +2237,13 @@ def test_feature_flags_v2_with_groups(self, *args):
         )
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id="example_id")
-            self.assertEqual(response.json()["featureFlags"], {})
+        response = self._post_decide(api_version=2, distinct_id="example_id", assert_num_queries=4)
+        self.assertEqual(response.json()["featureFlags"], {})
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id="example_id", groups={"organization": "foo"})
-            self.assertEqual(response.json()["featureFlags"], {"groups-flag": True})
+        response = self._post_decide(
+            api_version=2, distinct_id="example_id", groups={"organization": "foo"}, assert_num_queries=4
+        )
+        self.assertEqual(response.json()["featureFlags"], {"groups-flag": True})
 
     def test_feature_flags_with_personal_api_key(self, *args):
         key_value = generate_random_token_personal()
@@ -2365,16 +2315,13 @@ def test_flag_with_regular_cohorts(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(5):
-            response = self._post_decide(api_version=3, distinct_id="example_id_1")
-            self.assertEqual(response.json()["featureFlags"], {"cohort-flag": True})
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
+        response = self._post_decide(api_version=3, distinct_id="example_id_1", assert_num_queries=5)
+        self.assertEqual(response.json()["featureFlags"], {"cohort-flag": True})
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
 
-        with self.assertNumQueries(5):
-            # get cohort, get person filter
-            response = self._post_decide(api_version=3, distinct_id="another_id")
-            self.assertEqual(response.json()["featureFlags"], {"cohort-flag": False})
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
+        response = self._post_decide(api_version=3, distinct_id="another_id", assert_num_queries=5)
+        self.assertEqual(response.json()["featureFlags"], {"cohort-flag": False})
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
 
     def test_flag_with_invalid_cohort_filter_condition(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -2443,10 +2390,9 @@ def test_flag_with_invalid_cohort_filter_condition(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(5):
-            response = self._post_decide(api_version=3, distinct_id=person1_distinct_id)
-            self.assertEqual(response.json()["featureFlags"], {"cohort-flag": False})
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
+        response = self._post_decide(api_version=3, distinct_id=person1_distinct_id, assert_num_queries=5)
+        self.assertEqual(response.json()["featureFlags"], {"cohort-flag": False})
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
 
     def test_flag_with_invalid_but_safe_cohort_filter_condition(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -2514,10 +2460,9 @@ def test_flag_with_invalid_but_safe_cohort_filter_condition(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(5):
-            response = self._post_decide(api_version=3, distinct_id=person1_distinct_id)
-            self.assertEqual(response.json()["featureFlags"], {"cohort-flag": True})
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
+        response = self._post_decide(api_version=3, distinct_id=person1_distinct_id, assert_num_queries=5)
+        self.assertEqual(response.json()["featureFlags"], {"cohort-flag": True})
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
 
     def test_flag_with_unknown_cohort(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -2545,10 +2490,9 @@ def test_flag_with_unknown_cohort(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(6):
-            response = self._post_decide(api_version=3, distinct_id="example_id_1")
-            self.assertEqual(response.json()["featureFlags"], {"cohort-flag": False, "simple-flag": True})
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
+        response = self._post_decide(api_version=3, distinct_id="example_id_1", assert_num_queries=6)
+        self.assertEqual(response.json()["featureFlags"], {"cohort-flag": False, "simple-flag": True})
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
 
     def test_flag_with_multiple_complex_unknown_cohort(self, *args):
         self.team.app_urls = ["https://example.com"]
@@ -2692,24 +2636,23 @@ def test_flag_with_multiple_complex_unknown_cohort(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(8):
-            # Each invalid cohort is queried only once
-            # 1. Select all valid cohorts
-            # 2. Select 99999 cohort
-            # 3. Select deleted cohort
-            # 4. Select cohort from other team
-            response = self._post_decide(api_version=3, distinct_id="example_id_1")
-            self.assertEqual(
-                response.json()["featureFlags"],
-                {
-                    "cohort-flag": False,
-                    "simple-flag": True,
-                    "cohort-flag-2": False,
-                    "cohort-flag-3": False,
-                    "cohort-flag-4": True,
-                },
-            )
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
+        # Each invalid cohort is queried only once
+        # 1. Select all valid cohorts
+        # 2. Select 99999 cohort
+        # 3. Select deleted cohort
+        # 4. Select cohort from other team
+        response = self._post_decide(api_version=3, distinct_id="example_id_1", assert_num_queries=8)
+        self.assertEqual(
+            response.json()["featureFlags"],
+            {
+                "cohort-flag": False,
+                "simple-flag": True,
+                "cohort-flag-2": False,
+                "cohort-flag-3": False,
+                "cohort-flag-4": True,
+            },
+        )
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], False)
 
     @snapshot_postgres_queries
     def test_flag_with_behavioural_cohorts(self, *args):
@@ -2748,15 +2691,13 @@ def test_flag_with_behavioural_cohorts(self, *args):
             created_by=self.user,
         )
 
-        with self.assertNumQueries(6):
-            response = self._post_decide(api_version=3, distinct_id="example_id_1")
-            self.assertEqual(response.json()["featureFlags"], {})
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], True)
+        response = self._post_decide(api_version=3, distinct_id="example_id_1", assert_num_queries=6)
+        self.assertEqual(response.json()["featureFlags"], {})
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], True)
 
-        with self.assertNumQueries(6):
-            response = self._post_decide(api_version=3, distinct_id="another_id")
-            self.assertEqual(response.json()["featureFlags"], {})
-            self.assertEqual(response.json()["errorsWhileComputingFlags"], True)
+        response = self._post_decide(api_version=3, distinct_id="another_id", assert_num_queries=6)
+        self.assertEqual(response.json()["featureFlags"], {})
+        self.assertEqual(response.json()["errorsWhileComputingFlags"], True)
 
     def test_personal_api_key_without_project_id(self, *args):
         key_value = generate_random_token_personal()
@@ -2912,20 +2853,21 @@ def test_geoip_disable(self, *args):
             },
         )
 
-        with self.assertNumQueries(4):
-            geoip_not_disabled_res = self._post_decide(api_version=3, ip=australia_ip, geoip_disable=False)
-            geoip_disabled_res = self._post_decide(api_version=3, ip=australia_ip, geoip_disable=True)
+        geoip_not_disabled_res = self._post_decide(
+            api_version=3, ip=australia_ip, geoip_disable=False, assert_num_queries=0
+        )
+        geoip_disabled_res = self._post_decide(api_version=3, ip=australia_ip, geoip_disable=True, assert_num_queries=4)
 
-            # person has geoip_country_name set to India, but australia-feature is true, because geoip resolution of current IP is enabled
-            self.assertEqual(
-                geoip_not_disabled_res.json()["featureFlags"],
-                {"australia-feature": True, "india-feature": False},
-            )
-            # person has geoip_country_name set to India, and australia-feature is false, because geoip resolution of current IP is disabled
-            self.assertEqual(
-                geoip_disabled_res.json()["featureFlags"],
-                {"australia-feature": False, "india-feature": True},
-            )
+        # person has geoip_country_name set to India, but australia-feature is true, because geoip resolution of current IP is enabled
+        self.assertEqual(
+            geoip_not_disabled_res.json()["featureFlags"],
+            {"australia-feature": True, "india-feature": False},
+        )
+        # person has geoip_country_name set to India, and australia-feature is false, because geoip resolution of current IP is disabled
+        self.assertEqual(
+            geoip_disabled_res.json()["featureFlags"],
+            {"australia-feature": False, "india-feature": True},
+        )
 
         # test for falsy/truthy values
         geoip_not_disabled_res = self._post_decide(api_version=3, ip=australia_ip, geoip_disable="0")
@@ -2999,9 +2941,8 @@ def test_disable_flags(self, *args):
             },
         )
 
-        with self.assertNumQueries(0):
-            flag_disabled_res = self._post_decide(api_version=3, ip=australia_ip, disable_flags=True)
-            self.assertEqual(flag_disabled_res.json()["featureFlags"], {})
+        flag_disabled_res = self._post_decide(api_version=3, ip=australia_ip, disable_flags=True, assert_num_queries=0)
+        self.assertEqual(flag_disabled_res.json()["featureFlags"], {})
 
         # test for falsy/truthy values
         flags_not_disabled_res = self._post_decide(api_version=3, ip=australia_ip, disable_flags="0")
@@ -3051,30 +2992,30 @@ def test_decide_doesnt_error_out_when_database_is_down(self, *args):
             {"endpoint": "/e/"},
         )
 
-        # now database is down
-        with connection.execute_wrapper(QueryTimeoutWrapper()):
-            response = self._post_decide(api_version=2, origin="https://random.example.com").json()
+        response = self._post_decide(
+            api_version=2, origin="https://random.example.com", simulate_database_timeout=True
+        ).json()
 
-            self.assertEqual(
-                response["sessionRecording"],
-                make_session_recording_decide_response(
-                    {
-                        "sampleRate": "0.20",
-                    }
-                ),
-            )
+        self.assertEqual(
+            response["sessionRecording"],
+            make_session_recording_decide_response(
+                {
+                    "sampleRate": "0.20",
+                }
+            ),
+        )
 
-            self.assertEqual(response["supportedCompression"], ["gzip", "gzip-js"])
-            self.assertEqual(response["siteApps"], [])
-            self.assertEqual(
-                response["capturePerformance"],
-                {"network_timing": True, "web_vitals": False, "web_vitals_allowed_metrics": None},
-            )
-            self.assertEqual(
-                response["autocaptureExceptions"],
-                {"endpoint": "/e/"},
-            )
-            self.assertEqual(response["featureFlags"], {})
+        self.assertEqual(response["supportedCompression"], ["gzip", "gzip-js"])
+        self.assertEqual(response["siteApps"], [])
+        self.assertEqual(
+            response["capturePerformance"],
+            {"network_timing": True, "web_vitals": False, "web_vitals_allowed_metrics": None},
+        )
+        self.assertEqual(
+            response["autocaptureExceptions"],
+            {"endpoint": "/e/"},
+        )
+        self.assertEqual(response["featureFlags"], {})
 
     def test_decide_with_json_and_numeric_distinct_ids(self, *args):
         self.client.logout()
@@ -3107,44 +3048,41 @@ def test_decide_with_json_and_numeric_distinct_ids(self, *args):
         self._post_decide(api_version=2, distinct_id="a")
 
         # caching flag definitions mean fewer queries
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id=12345)
-            self.assertEqual(response.json()["featureFlags"], {"random-flag": True})
+        response = self._post_decide(api_version=2, distinct_id=12345, assert_num_queries=4)
+        self.assertEqual(response.json()["featureFlags"], {"random-flag": True})
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(
-                api_version=2,
-                distinct_id={
-                    "id": 33040,
-                    "shopify_domain": "xxx.myshopify.com",
-                    "shopify_token": "shpat_xxxx",
-                    "created_at": "2023-04-17T08:55:34.624Z",
-                    "updated_at": "2023-04-21T08:43:34.479",
-                },
-            )
-            self.assertEqual(
-                response.json()["featureFlags"],
-                {"random-flag": True, "filer-by-property": True},
-            )
+        response = self._post_decide(
+            api_version=2,
+            distinct_id={
+                "id": 33040,
+                "shopify_domain": "xxx.myshopify.com",
+                "shopify_token": "shpat_xxxx",
+                "created_at": "2023-04-17T08:55:34.624Z",
+                "updated_at": "2023-04-21T08:43:34.479",
+            },
+            assert_num_queries=4,
+        )
+        self.assertEqual(
+            response.json()["featureFlags"],
+            {"random-flag": True, "filer-by-property": True},
+        )
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(
-                api_version=2,
-                distinct_id="{'id': 33040, 'shopify_domain': 'xxx.myshopify.com', 'shopify_token': 'shpat_xxxx', 'created_at': '2023-04-17T08:55:34.624Z', 'updated_at': '2023-04-21T08:43:34.479'",
-            )
-            self.assertEqual(response.json()["featureFlags"], {"random-flag": True})
+        response = self._post_decide(
+            api_version=2,
+            distinct_id="{'id': 33040, 'shopify_domain': 'xxx.myshopify.com', 'shopify_token': 'shpat_xxxx', 'created_at': '2023-04-17T08:55:34.624Z', 'updated_at': '2023-04-21T08:43:34.479'",
+            assert_num_queries=4,
+        )
+        self.assertEqual(response.json()["featureFlags"], {"random-flag": True})
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id={"x": "y"})
-            self.assertEqual(
-                response.json()["featureFlags"],
-                {"random-flag": True, "filer-by-property": True},
-            )
+        response = self._post_decide(api_version=2, distinct_id={"x": "y"}, assert_num_queries=4)
+        self.assertEqual(
+            response.json()["featureFlags"],
+            {"random-flag": True, "filer-by-property": True},
+        )
 
-        with self.assertNumQueries(4):
-            response = self._post_decide(api_version=2, distinct_id={"x": "z"})
-            self.assertEqual(response.json()["featureFlags"], {"random-flag": True})
-            # need to pass in exact string to get the property flag
+        response = self._post_decide(api_version=2, distinct_id={"x": "z"}, assert_num_queries=4)
+        self.assertEqual(response.json()["featureFlags"], {"random-flag": True})
+        # need to pass in exact string to get the property flag
 
     def test_rate_limits(self, *args):
         with self.settings(
@@ -3613,69 +3551,16 @@ def test_decide_analytics_does_not_fire_for_survey_targeting_flags(self, *args):
     @patch("posthog.models.feature_flag.flag_analytics.CACHE_BUCKET_SIZE", 10)
     def test_decide_new_capture_activation(self, *args):
         self.client.logout()
-        with self.settings(NEW_ANALYTICS_CAPTURE_TEAM_IDS={str(self.team.id)}, NEW_ANALYTICS_CAPTURE_SAMPLING_RATE=1.0):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, 200)
-            self.assertTrue("analytics" in response.json())
-            self.assertEqual(response.json()["analytics"]["endpoint"], "/i/v0/e/")
-
-        with self.settings(
-            NEW_ANALYTICS_CAPTURE_TEAM_IDS={str(self.team.id)},
-            NEW_ANALYTICS_CAPTURE_SAMPLING_RATE=1.0,
-            NEW_ANALYTICS_CAPTURE_ENDPOINT="/custom",
-        ):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, 200)
-            self.assertTrue("analytics" in response.json())
-            self.assertEqual(response.json()["analytics"]["endpoint"], "/custom")
-
-        with self.settings(NEW_ANALYTICS_CAPTURE_TEAM_IDS={"0"}, NEW_ANALYTICS_CAPTURE_SAMPLING_RATE=1.0):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, 200)
-            self.assertFalse("analytics" in response.json())
+        response = self._post_decide(api_version=3)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("analytics" in response.json())
+        self.assertEqual(response.json()["analytics"]["endpoint"], "/i/v0/e/")
 
-        with self.settings(NEW_ANALYTICS_CAPTURE_TEAM_IDS={str(self.team.id)}, NEW_ANALYTICS_CAPTURE_SAMPLING_RATE=0):
+        with self.settings(NEW_ANALYTICS_CAPTURE_EXCLUDED_TEAM_IDS={str(self.team.id)}):
             response = self._post_decide(api_version=3)
             self.assertEqual(response.status_code, 200)
             self.assertFalse("analytics" in response.json())
 
-        with self.settings(NEW_ANALYTICS_CAPTURE_TEAM_IDS={"0", "*"}, NEW_ANALYTICS_CAPTURE_SAMPLING_RATE=1.0):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, 200)
-            self.assertTrue("analytics" in response.json())
-            self.assertEqual(response.json()["analytics"]["endpoint"], "/i/v0/e/")
-
-        with self.settings(
-            NEW_ANALYTICS_CAPTURE_TEAM_IDS={"*"},
-            NEW_ANALYTICS_CAPTURE_EXCLUDED_TEAM_IDS={str(self.team.id)},
-            NEW_ANALYTICS_CAPTURE_SAMPLING_RATE=1.0,
-        ):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, 200)
-            self.assertFalse("analytics" in response.json())
-
-    @patch("posthog.models.feature_flag.flag_analytics.CACHE_BUCKET_SIZE", 10)
-    def test_decide_new_capture_domains(self, *args):
-        self.client.logout()
-        with self.settings(
-            NEW_CAPTURE_ENDPOINTS_INCLUDED_TEAM_IDS={str(self.team.id)}, NEW_CAPTURE_ENDPOINTS_SAMPLING_RATE=1.0
-        ):
-            response = self._post_decide(api_version=3)
-            assert response.status_code == 200
-            assert response.json()["__preview_ingestion_endpoints"] is True
-
-        with self.settings(NEW_CAPTURE_ENDPOINTS_INCLUDED_TEAM_IDS={str(999)}, NEW_CAPTURE_ENDPOINTS_SAMPLING_RATE=1.0):
-            response = self._post_decide(api_version=3)
-            assert response.status_code == 200
-            assert "__preview_ingestion_endpoints" not in response.json()
-
-        with self.settings(
-            NEW_CAPTURE_ENDPOINTS_INCLUDED_TEAM_IDS={str(self.team.id)}, NEW_CAPTURE_ENDPOINTS_SAMPLING_RATE=0.0
-        ):
-            response = self._post_decide(api_version=3)
-            assert response.status_code == 200
-            assert "__preview_ingestion_endpoints" not in response.json()
-
     def test_decide_element_chain_as_string(self, *args):
         self.client.logout()
         with self.settings(
@@ -3696,16 +3581,48 @@ def test_decide_element_chain_as_string(self, *args):
 
     def test_decide_default_identified_only(self, *args):
         self.client.logout()
-        with self.settings(DEFAULT_IDENTIFIED_ONLY_TEAM_ID_MIN=str(1000000)):
-            response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, 200)
-            self.assertTrue("defaultIdentifiedOnly" in response.json())
-            self.assertFalse(response.json()["defaultIdentifiedOnly"])
-        team_id = self.team.id
-        with self.settings(DEFAULT_IDENTIFIED_ONLY_TEAM_ID_MIN=str(team_id)):
+        response = self._post_decide(api_version=3)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("defaultIdentifiedOnly" in response.json())
+        self.assertTrue(response.json()["defaultIdentifiedOnly"])
+
+
+class TestDecideRemoteConfig(TestDecide):
+    use_remote_config = True
+
+    def test_definitely_loads_via_remote_config(self, *args):
+        # NOTE: This is a sanity check test that we aren't just using the old decide logic
+
+        with patch.object(
+            RemoteConfig, "get_config_via_token", wraps=RemoteConfig.get_config_via_token
+        ) as wrapped_get_config_via_token:
             response = self._post_decide(api_version=3)
-            self.assertEqual(response.status_code, 200)
-            self.assertTrue(response.json()["defaultIdentifiedOnly"])
+            wrapped_get_config_via_token.assert_called_once()
+
+        # NOTE: If this changes it indicates something is wrong as we should keep this exact format
+        # for backwards compatibility
+        assert response.json() == snapshot(
+            {
+                "supportedCompression": ["gzip", "gzip-js"],
+                "captureDeadClicks": False,
+                "capturePerformance": {"network_timing": True, "web_vitals": False, "web_vitals_allowed_metrics": None},
+                "autocapture_opt_out": False,
+                "autocaptureExceptions": False,
+                "analytics": {"endpoint": "/i/v0/e/"},
+                "elementsChainAsString": True,
+                "sessionRecording": False,
+                "heatmaps": False,
+                "surveys": False,
+                "defaultIdentifiedOnly": True,
+                "siteApps": [],
+                "isAuthenticated": False,
+                "toolbarParams": {},
+                "config": {"enable_collect_everything": True},
+                "featureFlags": {},
+                "errorsWhileComputingFlags": False,
+                "featureFlagPayloads": {},
+            }
+        )
 
 
 class TestDatabaseCheckForDecide(BaseTest, QueryMatchingTest):
@@ -4730,7 +4647,7 @@ def test_site_apps_in_decide_use_replica(self, mock_is_connected):
         # update caches
         self._post_decide(api_version=3)
 
-        with self.assertNumQueries(8, using="replica"), self.assertNumQueries(0, using="default"):
+        with self.assertNumQueries(4, using="replica"), self.assertNumQueries(0, using="default"):
             response = self._post_decide(api_version=3)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
             injected = response.json()["siteApps"]
diff --git a/posthog/api/test/test_early_access_feature.py b/posthog/api/test/test_early_access_feature.py
index 311fbae3cb1d3..525490c4f949d 100644
--- a/posthog/api/test/test_early_access_feature.py
+++ b/posthog/api/test/test_early_access_feature.py
@@ -1,3 +1,4 @@
+import json
 from unittest.mock import ANY
 
 from rest_framework import status
@@ -7,6 +8,7 @@
 
 from posthog.models.early_access_feature import EarlyAccessFeature
 from posthog.models import FeatureFlag, Person
+from posthog.models.team.team_caching import set_team_in_cache
 from posthog.test.base import (
     APIBaseTest,
     BaseTest,
@@ -631,6 +633,109 @@ def test_early_access_features(self):
                 ],
             )
 
+    @snapshot_postgres_queries
+    def test_early_access_features_with_pre_env_cached_team(self):
+        Person.objects.create(
+            team=self.team,
+            distinct_ids=["example_id"],
+            properties={"email": "example@posthog.com"},
+        )
+
+        # This is precisely what the `set_team_in_cache()` would have set on Dec 9, 2024
+        cache.set(
+            f"team_token:{self.team.api_token}",
+            json.dumps(
+                {
+                    # Important: this serialization doesn't have `project_id`! It wasn't always part of CachingTeamSerializer
+                    "id": self.team.id,
+                    "uuid": str(self.team.uuid),
+                    "name": self.team.name,
+                    "api_token": self.team.api_token,
+                }
+            ),
+        )
+        feature_flag = FeatureFlag.objects.create(
+            team=self.team,
+            name=f"Feature Flag for Feature Sprocket",
+            key="sprocket",
+            rollout_percentage=0,
+            created_by=self.user,
+        )
+        feature = EarlyAccessFeature.objects.create(
+            team=self.team,
+            name="Sprocket",
+            description="A fancy new sprocket.",
+            stage="beta",
+            feature_flag=feature_flag,
+        )
+
+        self.client.logout()
+
+        with self.assertNumQueries(1):
+            response = self._get_features()
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.get("access-control-allow-origin"), "http://127.0.0.1:8000")
+
+            self.assertListEqual(
+                response.json()["earlyAccessFeatures"],
+                [
+                    {
+                        "id": str(feature.id),
+                        "name": "Sprocket",
+                        "description": "A fancy new sprocket.",
+                        "stage": "beta",
+                        "documentationUrl": "",
+                        "flagKey": "sprocket",
+                    }
+                ],
+            )
+
+    @snapshot_postgres_queries
+    def test_early_access_features_with_cached_team(self):
+        Person.objects.create(
+            team=self.team,
+            distinct_ids=["example_id"],
+            properties={"email": "example@posthog.com"},
+        )
+
+        # Slightly dirty to use the actual implementation of `set_team_in_cache()` here, but this tests how things are
+        set_team_in_cache(self.team.api_token)
+        feature_flag = FeatureFlag.objects.create(
+            team=self.team,
+            name=f"Feature Flag for Feature Sprocket",
+            key="sprocket",
+            rollout_percentage=0,
+            created_by=self.user,
+        )
+        feature = EarlyAccessFeature.objects.create(
+            team=self.team,
+            name="Sprocket",
+            description="A fancy new sprocket.",
+            stage="beta",
+            feature_flag=feature_flag,
+        )
+
+        self.client.logout()
+
+        with self.assertNumQueries(1):
+            response = self._get_features()
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.get("access-control-allow-origin"), "http://127.0.0.1:8000")
+
+            self.assertListEqual(
+                response.json()["earlyAccessFeatures"],
+                [
+                    {
+                        "id": str(feature.id),
+                        "name": "Sprocket",
+                        "description": "A fancy new sprocket.",
+                        "stage": "beta",
+                        "documentationUrl": "",
+                        "flagKey": "sprocket",
+                    }
+                ],
+            )
+
     def test_early_access_features_beta_only(self):
         Person.objects.create(
             team=self.team,
diff --git a/posthog/api/test/test_feature_flag.py b/posthog/api/test/test_feature_flag.py
index 86cee8950dfdf..4ae2d364d1f03 100644
--- a/posthog/api/test/test_feature_flag.py
+++ b/posthog/api/test/test_feature_flag.py
@@ -8,7 +8,7 @@
 from django.db.utils import OperationalError
 from django.test import TransactionTestCase
 from django.test.client import RequestFactory
-from django.utils import timezone
+from django.utils.timezone import now
 from freezegun.api import freeze_time
 from rest_framework import status
 
@@ -32,6 +32,9 @@
 from posthog.models.personal_api_key import PersonalAPIKey, hash_key_value
 from posthog.models.team.team import Team
 from posthog.models.utils import generate_random_token_personal
+from posthog.models.feature_flag.flag_status import (
+    FeatureFlagStatus,
+)
 from posthog.test.base import (
     APIBaseTest,
     ClickhouseTestMixin,
@@ -1259,7 +1262,7 @@ def test_my_flags_is_not_nplus1(self) -> None:
                 format="json",
             ).json()
 
-        with self.assertNumQueries(FuzzyInt(7, 8)):
+        with self.assertNumQueries(FuzzyInt(8, 9)):
             response = self.client.get(f"/api/projects/{self.team.id}/feature_flags/my_flags")
             self.assertEqual(response.status_code, status.HTTP_200_OK)
 
@@ -1458,73 +1461,91 @@ def test_create_feature_flag_usage_dashboard(self, mock_capture):
         self.assertEqual(len(tiles), 2)
         self.assertEqual(tiles[0].insight.name, "Feature Flag Called Total Volume")
         self.assertEqual(
-            tiles[0].insight.filters,
+            tiles[0].insight.query,
             {
-                "events": [
-                    {
-                        "id": "$feature_flag_called",
-                        "name": "$feature_flag_called",
-                        "type": "events",
-                    }
-                ],
-                "display": "ActionsLineGraph",
-                "insight": "TRENDS",
-                "interval": "day",
-                "breakdown": "$feature_flag_response",
-                "date_from": "-30d",
-                "properties": {
-                    "type": "AND",
-                    "values": [
-                        {
-                            "type": "AND",
-                            "values": [
-                                {
-                                    "key": "$feature_flag",
-                                    "type": "event",
-                                    "value": "alpha-feature",
-                                }
-                            ],
-                        }
-                    ],
+                "kind": "InsightVizNode",
+                "source": {
+                    "kind": "TrendsQuery",
+                    "series": [{"kind": "EventsNode", "name": "$feature_flag_called", "event": "$feature_flag_called"}],
+                    "interval": "day",
+                    "dateRange": {"date_from": "-30d", "explicitDate": False},
+                    "properties": {
+                        "type": "AND",
+                        "values": [
+                            {
+                                "type": "AND",
+                                "values": [
+                                    {
+                                        "key": "$feature_flag",
+                                        "type": "event",
+                                        "value": "alpha-feature",
+                                        "operator": "exact",
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                    "trendsFilter": {
+                        "display": "ActionsLineGraph",
+                        "showLegend": False,
+                        "yAxisScaleType": "linear",
+                        "showValuesOnSeries": False,
+                        "smoothingIntervals": 1,
+                        "showPercentStackView": False,
+                        "aggregationAxisFormat": "numeric",
+                        "showAlertThresholdLines": False,
+                    },
+                    "breakdownFilter": {"breakdown": "$feature_flag_response", "breakdown_type": "event"},
+                    "filterTestAccounts": False,
                 },
-                "breakdown_type": "event",
-                "filter_test_accounts": False,
             },
         )
         self.assertEqual(tiles[1].insight.name, "Feature Flag calls made by unique users per variant")
         self.assertEqual(
-            tiles[1].insight.filters,
+            tiles[1].insight.query,
             {
-                "events": [
-                    {
-                        "id": "$feature_flag_called",
-                        "math": "dau",
-                        "name": "$feature_flag_called",
-                        "type": "events",
-                    }
-                ],
-                "display": "ActionsTable",
-                "insight": "TRENDS",
-                "interval": "day",
-                "breakdown": "$feature_flag_response",
-                "date_from": "-30d",
-                "properties": {
-                    "type": "AND",
-                    "values": [
+                "kind": "InsightVizNode",
+                "source": {
+                    "kind": "TrendsQuery",
+                    "series": [
                         {
-                            "type": "AND",
-                            "values": [
-                                {
-                                    "key": "$feature_flag",
-                                    "type": "event",
-                                    "value": "alpha-feature",
-                                }
-                            ],
+                            "kind": "EventsNode",
+                            "math": "dau",
+                            "name": "$feature_flag_called",
+                            "event": "$feature_flag_called",
                         }
                     ],
+                    "interval": "day",
+                    "dateRange": {"date_from": "-30d", "explicitDate": False},
+                    "properties": {
+                        "type": "AND",
+                        "values": [
+                            {
+                                "type": "AND",
+                                "values": [
+                                    {
+                                        "key": "$feature_flag",
+                                        "type": "event",
+                                        "value": "alpha-feature",
+                                        "operator": "exact",
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                    "trendsFilter": {
+                        "display": "ActionsTable",
+                        "showLegend": False,
+                        "yAxisScaleType": "linear",
+                        "showValuesOnSeries": False,
+                        "smoothingIntervals": 1,
+                        "showPercentStackView": False,
+                        "aggregationAxisFormat": "numeric",
+                        "showAlertThresholdLines": False,
+                    },
+                    "breakdownFilter": {"breakdown": "$feature_flag_response", "breakdown_type": "event"},
+                    "filterTestAccounts": False,
                 },
-                "breakdown_type": "event",
-                "filter_test_accounts": False,
             },
         )
 
@@ -1552,153 +1573,191 @@ def test_create_feature_flag_usage_dashboard(self, mock_capture):
         self.assertEqual(len(tiles), 4)
         self.assertEqual(tiles[0].insight.name, "Feature Flag Called Total Volume")
         self.assertEqual(
-            tiles[0].insight.filters,
+            tiles[0].insight.query,
             {
-                "events": [
-                    {
-                        "id": "$feature_flag_called",
-                        "name": "$feature_flag_called",
-                        "type": "events",
-                    }
-                ],
-                "display": "ActionsLineGraph",
-                "insight": "TRENDS",
-                "interval": "day",
-                "breakdown": "$feature_flag_response",
-                "date_from": "-30d",
-                "properties": {
-                    "type": "AND",
-                    "values": [
-                        {
-                            "type": "AND",
-                            "values": [
-                                {
-                                    "key": "$feature_flag",
-                                    "type": "event",
-                                    "value": "alpha-feature",
-                                }
-                            ],
-                        }
-                    ],
+                "kind": "InsightVizNode",
+                "source": {
+                    "kind": "TrendsQuery",
+                    "series": [{"kind": "EventsNode", "name": "$feature_flag_called", "event": "$feature_flag_called"}],
+                    "interval": "day",
+                    "dateRange": {"date_from": "-30d", "explicitDate": False},
+                    "properties": {
+                        "type": "AND",
+                        "values": [
+                            {
+                                "type": "AND",
+                                "values": [
+                                    {
+                                        "key": "$feature_flag",
+                                        "type": "event",
+                                        "value": "alpha-feature",
+                                        "operator": "exact",
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                    "trendsFilter": {
+                        "display": "ActionsLineGraph",
+                        "showLegend": False,
+                        "yAxisScaleType": "linear",
+                        "showValuesOnSeries": False,
+                        "smoothingIntervals": 1,
+                        "showPercentStackView": False,
+                        "aggregationAxisFormat": "numeric",
+                        "showAlertThresholdLines": False,
+                    },
+                    "breakdownFilter": {"breakdown": "$feature_flag_response", "breakdown_type": "event"},
+                    "filterTestAccounts": False,
                 },
-                "breakdown_type": "event",
-                "filter_test_accounts": False,
             },
         )
         self.assertEqual(tiles[1].insight.name, "Feature Flag calls made by unique users per variant")
         self.assertEqual(
-            tiles[1].insight.filters,
+            tiles[1].insight.query,
             {
-                "events": [
-                    {
-                        "id": "$feature_flag_called",
-                        "math": "dau",
-                        "name": "$feature_flag_called",
-                        "type": "events",
-                    }
-                ],
-                "display": "ActionsTable",
-                "insight": "TRENDS",
-                "interval": "day",
-                "breakdown": "$feature_flag_response",
-                "date_from": "-30d",
-                "properties": {
-                    "type": "AND",
-                    "values": [
+                "kind": "InsightVizNode",
+                "source": {
+                    "kind": "TrendsQuery",
+                    "series": [
                         {
-                            "type": "AND",
-                            "values": [
-                                {
-                                    "key": "$feature_flag",
-                                    "type": "event",
-                                    "value": "alpha-feature",
-                                }
-                            ],
+                            "kind": "EventsNode",
+                            "math": "dau",
+                            "name": "$feature_flag_called",
+                            "event": "$feature_flag_called",
                         }
                     ],
+                    "interval": "day",
+                    "dateRange": {"date_from": "-30d", "explicitDate": False},
+                    "properties": {
+                        "type": "AND",
+                        "values": [
+                            {
+                                "type": "AND",
+                                "values": [
+                                    {
+                                        "key": "$feature_flag",
+                                        "type": "event",
+                                        "value": "alpha-feature",
+                                        "operator": "exact",
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                    "trendsFilter": {
+                        "display": "ActionsTable",
+                        "showLegend": False,
+                        "yAxisScaleType": "linear",
+                        "showValuesOnSeries": False,
+                        "smoothingIntervals": 1,
+                        "showPercentStackView": False,
+                        "aggregationAxisFormat": "numeric",
+                        "showAlertThresholdLines": False,
+                    },
+                    "breakdownFilter": {"breakdown": "$feature_flag_response", "breakdown_type": "event"},
+                    "filterTestAccounts": False,
                 },
-                "breakdown_type": "event",
-                "filter_test_accounts": False,
             },
         )
 
         # enriched insights
         self.assertEqual(tiles[2].insight.name, "Feature Interaction Total Volume")
         self.assertEqual(
-            tiles[2].insight.filters,
+            tiles[2].insight.query,
             {
-                "events": [
-                    {
-                        "id": "$feature_interaction",
-                        "name": "Feature Interaction - Total",
-                        "type": "events",
-                    },
-                    {
-                        "id": "$feature_interaction",
-                        "math": "dau",
-                        "name": "Feature Interaction - Unique users",
-                        "type": "events",
-                    },
-                ],
-                "display": "ActionsLineGraph",
-                "insight": "TRENDS",
-                "interval": "day",
-                "date_from": "-30d",
-                "properties": {
-                    "type": "AND",
-                    "values": [
+                "kind": "InsightVizNode",
+                "source": {
+                    "kind": "TrendsQuery",
+                    "series": [
+                        {"kind": "EventsNode", "name": "Feature Interaction - Total", "event": "$feature_interaction"},
                         {
-                            "type": "AND",
-                            "values": [
-                                {
-                                    "key": "feature_flag",
-                                    "type": "event",
-                                    "value": "alpha-feature",
-                                }
-                            ],
-                        }
+                            "kind": "EventsNode",
+                            "math": "dau",
+                            "name": "Feature Interaction - Unique users",
+                            "event": "$feature_interaction",
+                        },
                     ],
+                    "interval": "day",
+                    "dateRange": {"date_from": "-30d", "explicitDate": False},
+                    "properties": {
+                        "type": "AND",
+                        "values": [
+                            {
+                                "type": "AND",
+                                "values": [
+                                    {
+                                        "key": "feature_flag",
+                                        "type": "event",
+                                        "value": "alpha-feature",
+                                        "operator": "exact",
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                    "trendsFilter": {
+                        "display": "ActionsLineGraph",
+                        "showLegend": False,
+                        "yAxisScaleType": "linear",
+                        "showValuesOnSeries": False,
+                        "smoothingIntervals": 1,
+                        "showPercentStackView": False,
+                        "aggregationAxisFormat": "numeric",
+                        "showAlertThresholdLines": False,
+                    },
+                    "breakdownFilter": {"breakdown_type": "event"},
+                    "filterTestAccounts": False,
                 },
-                "filter_test_accounts": False,
             },
         )
         self.assertEqual(tiles[3].insight.name, "Feature Viewed Total Volume")
         self.assertEqual(
-            tiles[3].insight.filters,
+            tiles[3].insight.query,
             {
-                "events": [
-                    {
-                        "id": "$feature_view",
-                        "name": "Feature View - Total",
-                        "type": "events",
-                    },
-                    {
-                        "id": "$feature_view",
-                        "math": "dau",
-                        "name": "Feature View - Unique users",
-                        "type": "events",
-                    },
-                ],
-                "display": "ActionsLineGraph",
-                "insight": "TRENDS",
-                "interval": "day",
-                "date_from": "-30d",
-                "properties": {
-                    "type": "AND",
-                    "values": [
+                "kind": "InsightVizNode",
+                "source": {
+                    "kind": "TrendsQuery",
+                    "series": [
+                        {"kind": "EventsNode", "name": "Feature View - Total", "event": "$feature_view"},
                         {
-                            "type": "AND",
-                            "values": [
-                                {
-                                    "key": "feature_flag",
-                                    "type": "event",
-                                    "value": "alpha-feature",
-                                }
-                            ],
-                        }
+                            "kind": "EventsNode",
+                            "math": "dau",
+                            "name": "Feature View - Unique users",
+                            "event": "$feature_view",
+                        },
                     ],
+                    "interval": "day",
+                    "dateRange": {"date_from": "-30d", "explicitDate": False},
+                    "properties": {
+                        "type": "AND",
+                        "values": [
+                            {
+                                "type": "AND",
+                                "values": [
+                                    {
+                                        "key": "feature_flag",
+                                        "type": "event",
+                                        "value": "alpha-feature",
+                                        "operator": "exact",
+                                    }
+                                ],
+                            }
+                        ],
+                    },
+                    "trendsFilter": {
+                        "display": "ActionsLineGraph",
+                        "showLegend": False,
+                        "yAxisScaleType": "linear",
+                        "showValuesOnSeries": False,
+                        "smoothingIntervals": 1,
+                        "showPercentStackView": False,
+                        "aggregationAxisFormat": "numeric",
+                        "showAlertThresholdLines": False,
+                    },
+                    "breakdownFilter": {"breakdown_type": "event"},
+                    "filterTestAccounts": False,
                 },
-                "filter_test_accounts": False,
             },
         )
 
@@ -2229,7 +2288,7 @@ def test_local_evaluation_for_invalid_cohorts(self, mock_capture):
 
         self.client.logout()
 
-        with self.assertNumQueries(16):
+        with self.assertNumQueries(18):
             # 1. SAVEPOINT
             # 2. SELECT "posthog_personalapikey"."id",
             # 3. RELEASE SAVEPOINT
@@ -2242,10 +2301,12 @@ def test_local_evaluation_for_invalid_cohorts(self, mock_capture):
             # 10. SELECT "posthog_organizationmembership"."id",
             # 11. SELECT "posthog_cohort"."id"  -- all cohorts
             # 12. SELECT "posthog_featureflag"."id", "posthog_featureflag"."key", -- all flags
-            # 13. SELECT "posthog_cohort". id = 99999
-            # 14. SELECT "posthog_cohort". id = deleted cohort
-            # 15. SELECT "posthog_cohort". id = cohort from other team
-            # 16. SELECT "posthog_grouptypemapping"."id", -- group type mapping
+            # 13. SELECT "posthog_team"."id", "posthog_team"."uuid",
+            # 14. SELECT "posthog_cohort". id = 99999
+            # 15. SELECT "posthog_team"."id", "posthog_team"."uuid",
+            # 16. SELECT "posthog_cohort". id = deleted cohort
+            # 17. SELECT "posthog_cohort". id = cohort from other team
+            # 18. SELECT "posthog_grouptypemapping"."id", -- group type mapping
 
             response = self.client.get(
                 f"/api/feature_flag/local_evaluation?token={self.team.api_token}&send_cohorts",
@@ -4230,7 +4291,7 @@ def test_creating_static_cohort_with_deleted_flag(self):
             name="some cohort",
         )
 
-        with self.assertNumQueries(1):
+        with self.assertNumQueries(2):
             get_cohort_actors_for_feature_flag(cohort.pk, "some-feature", self.team.pk)
 
         cohort.refresh_from_db()
@@ -4268,7 +4329,7 @@ def test_creating_static_cohort_with_inactive_flag(self):
             name="some cohort",
         )
 
-        with self.assertNumQueries(1):
+        with self.assertNumQueries(2):
             get_cohort_actors_for_feature_flag(cohort.pk, "some-feature2", self.team.pk)
 
         cohort.refresh_from_db()
@@ -4307,7 +4368,7 @@ def test_creating_static_cohort_with_group_flag(self):
             name="some cohort",
         )
 
-        with self.assertNumQueries(1):
+        with self.assertNumQueries(2):
             get_cohort_actors_for_feature_flag(cohort.pk, "some-feature3", self.team.pk)
 
         cohort.refresh_from_db()
@@ -4339,7 +4400,7 @@ def test_creating_static_cohort_with_no_person_distinct_ids(self):
             name="some cohort",
         )
 
-        with self.assertNumQueries(5):
+        with self.assertNumQueries(6):
             get_cohort_actors_for_feature_flag(cohort.pk, "some-feature2", self.team.pk)
 
         cohort.refresh_from_db()
@@ -4357,7 +4418,7 @@ def test_creating_static_cohort_with_non_existing_flag(self):
             name="some cohort",
         )
 
-        with self.assertNumQueries(1):
+        with self.assertNumQueries(2):
             get_cohort_actors_for_feature_flag(cohort.pk, "some-feature2", self.team.pk)
 
         cohort.refresh_from_db()
@@ -4934,7 +4995,7 @@ def test_user_blast_radius_with_multiple_static_cohorts(self):
                 properties={"group": f"{i}"},
             )
 
-        cohort1 = Cohort.objects.create(team=self.team, groups=[], is_static=True, last_calculation=timezone.now())
+        cohort1 = Cohort.objects.create(team=self.team, groups=[], is_static=True, last_calculation=now())
         cohort1.insert_users_by_list(["person0", "person1", "person2"])
 
         cohort2 = Cohort.objects.create(
@@ -6036,3 +6097,466 @@ def test_feature_flags_v3_with_experience_continuity_and_incident_mode(self, moc
         self.assertTrue(all_flags["property-flag"])
         self.assertTrue(all_flags["default-flag"])
         self.assertFalse(errors)
+
+
+class TestFeatureFlagStatus(APIBaseTest, ClickhouseTestMixin):
+    def setUp(self):
+        cache.clear()
+
+        # delete all keys in redis
+        r = redis.get_client()
+        for key in r.scan_iter("*"):
+            r.delete(key)
+        return super().setUp()
+
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+
+    def assert_expected_response(
+        self, feature_flag_id: int, expected_status: FeatureFlagStatus, expected_reason: Optional[str] = None
+    ):
+        response = self.client.get(
+            f"/api/projects/{self.team.id}/feature_flags/{feature_flag_id}/status",
+        )
+        self.assertEqual(
+            response.status_code,
+            status.HTTP_404_NOT_FOUND if expected_status == FeatureFlagStatus.UNKNOWN else status.HTTP_200_OK,
+        )
+        response_data = response.json()
+        self.assertEqual(response_data.get("status"), expected_status)
+        if expected_reason is not None:
+            self.assertEqual(response_data.get("reason"), expected_reason)
+
+    def test_flag_status_reasons(self):
+        FeatureFlag.objects.all().delete()
+
+        # Request status for non-existent flag
+        self.assert_expected_response(1, FeatureFlagStatus.UNKNOWN, "Flag could not be found")
+
+        # Request status for flag that has been soft deleted
+        deleted_flag = FeatureFlag.objects.create(
+            name="Deleted feature flag",
+            key="deleted-feature-flag",
+            team=self.team,
+            deleted=True,
+            active=True,
+        )
+        self.assert_expected_response(deleted_flag.id, FeatureFlagStatus.DELETED, "Flag has been deleted")
+
+        # Request status for flag that is disabled, but recently called
+        disabled_flag = FeatureFlag.objects.create(
+            name="Disabled feature flag",
+            key="disabled-feature-flag",
+            team=self.team,
+            active=False,
+        )
+
+        self.assert_expected_response(disabled_flag.id, FeatureFlagStatus.ACTIVE)
+
+        # Request status for flag that has super group rolled out to <100%
+        fifty_percent_super_group_flag = FeatureFlag.objects.create(
+            name="50 percent super group flag",
+            key="50-percent-super-group-flag",
+            team=self.team,
+            active=True,
+            filters={"super_groups": [{"rollout_percentage": 50, "properties": []}]},
+        )
+
+        self.assert_expected_response(fifty_percent_super_group_flag.id, FeatureFlagStatus.ACTIVE)
+
+        # Request status for flag that has super group rolled out to 100% and specific properties
+        fully_rolled_out_super_group_flag_with_properties = FeatureFlag.objects.create(
+            name="100 percent super group with properties flag",
+            key="100-percent-super-group-with-properties-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "super_groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "$feature_enrollment/cool-new-feature",
+                                "type": "person",
+                                "value": ["true"],
+                                "operator": "exact",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    }
+                ]
+            },
+        )
+
+        self.assert_expected_response(fully_rolled_out_super_group_flag_with_properties.id, FeatureFlagStatus.ACTIVE)
+
+        # Request status for flag that has super group rolled out to 100% and has no specific properties
+        fully_rolled_out_super_group_flag = FeatureFlag.objects.create(
+            name="100 percent super group flag",
+            key="100-percent-super-group-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "super_groups": [
+                    {
+                        "properties": [],
+                        "rollout_percentage": 100,
+                    }
+                ]
+            },
+        )
+        self.assert_expected_response(
+            fully_rolled_out_super_group_flag.id, FeatureFlagStatus.STALE, "Super group is rolled out to 100%"
+        )
+
+        # Request status for flag that has holdout group rolled out to <100%
+        fifty_percent_holdout_group_flag = FeatureFlag.objects.create(
+            name="50 percent holdout group flag",
+            key="50-percent-holdout-group-flag",
+            team=self.team,
+            active=True,
+            filters={"holdout_groups": [{"rollout_percentage": 50, "properties": []}]},
+        )
+
+        self.assert_expected_response(fifty_percent_holdout_group_flag.id, FeatureFlagStatus.ACTIVE)
+
+        # Request status for flag that has holdout group rolled out to 100% and specific properties
+        fully_rolled_out_holdout_group_flag_with_properties = FeatureFlag.objects.create(
+            name="100 percent holdout group with properties flag",
+            key="100-percent-holdout-group-with-properties-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "holdout_groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "name",
+                                "type": "person",
+                                "value": ["Smith"],
+                                "operator": "contains",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    }
+                ]
+            },
+        )
+
+        self.assert_expected_response(fully_rolled_out_holdout_group_flag_with_properties.id, FeatureFlagStatus.ACTIVE)
+
+        # Request status for flag that has holdout group rolled out to 100% and has no specific properties
+        fully_rolled_out_holdout_group_flag = FeatureFlag.objects.create(
+            name="100 percent holdout group flag",
+            key="100-percent-holdout-group-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "holdout_groups": [
+                    {
+                        "properties": [],
+                        "rollout_percentage": 100,
+                    }
+                ]
+            },
+        )
+        self.assert_expected_response(
+            fully_rolled_out_holdout_group_flag.id, FeatureFlagStatus.STALE, "Holdout group is rolled out to 100%"
+        )
+
+        # Request status for multivariate flag with no variants set to 100%
+        multivariate_flag_no_rolled_out_variants = FeatureFlag.objects.create(
+            name="Multivariate flag with no variants set to 100%",
+            key="multivariate-no-rolled-out-variants-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "multivariate": {
+                    "variants": [
+                        {"key": "var1key", "name": "test", "rollout_percentage": 50},
+                        {"key": "var2key", "name": "control", "rollout_percentage": 50},
+                    ],
+                }
+            },
+        )
+
+        self.assert_expected_response(multivariate_flag_no_rolled_out_variants.id, FeatureFlagStatus.ACTIVE)
+
+        # Request status for multivariate flag with no variants set to 100%
+        multivariate_flag_rolled_out_variant = FeatureFlag.objects.create(
+            name="Multivariate flag with variant set to 100%",
+            key="multivariate-rolled-out-variant-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "multivariate": {
+                    "variants": [
+                        {"key": "test", "rollout_percentage": 100},
+                        {"key": "control", "rollout_percentage": 0},
+                    ],
+                },
+                "groups": [{"variant": None, "properties": [], "rollout_percentage": 100}],
+            },
+        )
+        self.assert_expected_response(
+            multivariate_flag_rolled_out_variant.id,
+            FeatureFlagStatus.STALE,
+            'This flag will always use the variant "test"',
+        )
+
+        # Request status for multivariate flag with a variant set to 100% but no release condition set to 100%
+        multivariate_flag_rolled_out_variant_no_rolled_out_release = FeatureFlag.objects.create(
+            name="Multivariate flag with variant set to 100%, no release condition set to 100%",
+            key="multivariate-rolled-out-variant-no-release-rolled-out-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "multivariate": {
+                    "variants": [
+                        {"key": "var1key", "name": "test", "rollout_percentage": 100},
+                        {"key": "var2key", "name": "control", "rollout_percentage": 0},
+                    ],
+                },
+                "groups": [
+                    {"variant": None, "properties": [], "rollout_percentage": 20},
+                    {"variant": None, "properties": [], "rollout_percentage": 30},
+                ],
+            },
+        )
+
+        self.assert_expected_response(
+            multivariate_flag_rolled_out_variant_no_rolled_out_release.id,
+            FeatureFlagStatus.ACTIVE,
+        )
+
+        # Request status for multivariate flag with a variant set to 100% but no release condition set to 100%
+        multivariate_flag_rolled_out_release_condition_half_variant = FeatureFlag.objects.create(
+            name="Multivariate flag with release condition set to 100%, but variants still 50%",
+            key="multivariate-rolled-out-release-half-variant-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "multivariate": {
+                    "variants": [
+                        {"key": "var1key", "name": "test", "rollout_percentage": 50},
+                        {"key": "var2key", "name": "control", "rollout_percentage": 50},
+                    ],
+                },
+                "groups": [
+                    {"variant": None, "properties": [], "rollout_percentage": 100},
+                ],
+            },
+        )
+
+        self.assert_expected_response(
+            multivariate_flag_rolled_out_release_condition_half_variant.id,
+            FeatureFlagStatus.ACTIVE,
+        )
+
+        # Request status for multivariate flag with variants set to 100% and a filtered release condition
+        multivariate_flag_rolled_out_variant_rolled_out_filtered_release = FeatureFlag.objects.create(
+            name="Multivariate flag with variant and release condition set to 100%",
+            key="multivariate-rolled-out-variant-and-release-condition-with-properties-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "multivariate": {
+                    "variants": [
+                        {"key": "var1key", "name": "test", "rollout_percentage": 100},
+                        {"key": "var2key", "name": "control", "rollout_percentage": 0},
+                    ],
+                },
+                "groups": [
+                    {
+                        "variant": None,
+                        "properties": [
+                            {
+                                "key": "name",
+                                "type": "person",
+                                "value": ["Smith"],
+                                "operator": "contains",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    }
+                ],
+            },
+        )
+
+        self.assert_expected_response(
+            multivariate_flag_rolled_out_variant_rolled_out_filtered_release.id,
+            FeatureFlagStatus.ACTIVE,
+        )
+
+        # Request status for multivariate flag with no variants set to 100%, but a filtered and fully rolled out release condition has variant override
+        multivariate_flag_filtered_rolled_out_release_with_override = FeatureFlag.objects.create(
+            name="Multivariate flag with release condition set to 100% and override",
+            key="multivariate-rolled-out-filtered-release-condition-and-override-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "multivariate": {
+                    "variants": [
+                        {"key": "var1key", "name": "test", "rollout_percentage": 60},
+                        {"key": "var2key", "name": "control", "rollout_percentage": 40},
+                    ],
+                },
+                "groups": [
+                    {
+                        "variant": "var1key",
+                        "properties": [
+                            {
+                                "key": "name",
+                                "type": "person",
+                                "value": ["Smith"],
+                                "operator": "contains",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    }
+                ],
+            },
+        )
+
+        self.assert_expected_response(
+            multivariate_flag_filtered_rolled_out_release_with_override.id,
+            FeatureFlagStatus.ACTIVE,
+        )
+
+        # Request status for multivariate flag with no variants set to 100%, but fully rolled out release condition has variant override
+        multivariate_flag_rolled_out_release_with_override = FeatureFlag.objects.create(
+            name="Multivariate flag with release condition set to 100% and override",
+            key="multivariate-rolled-out-release-condition-and-override-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "multivariate": {
+                    "variants": [
+                        {"key": "test", "rollout_percentage": 60},
+                        {"key": "control", "rollout_percentage": 40},
+                    ],
+                },
+                "groups": [
+                    {
+                        "variant": "test",
+                        "properties": [],
+                        "rollout_percentage": 100,
+                    }
+                ],
+            },
+        )
+        self.assert_expected_response(
+            multivariate_flag_rolled_out_release_with_override.id,
+            FeatureFlagStatus.STALE,
+            'This flag will always use the variant "test"',
+        )
+
+        # Request status for boolean flag with empty filters
+        boolean_flag_empty_filters = FeatureFlag.objects.create(
+            name="Boolean flag with empty filters",
+            key="boolean-empty-filters-flag",
+            team=self.team,
+            active=True,
+            filters={},
+        )
+        self.assert_expected_response(
+            boolean_flag_empty_filters.id,
+            FeatureFlagStatus.STALE,
+            'This boolean flag will always evaluate to "true"',
+        )
+
+        # Request status for boolean flag with no fully rolled out release conditions
+        boolean_flag_no_rolled_out_release_conditions = FeatureFlag.objects.create(
+            name="Boolean flag with no release condition set to 100%",
+            key="boolean-no-rolled-out-release-conditions-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "groups": [
+                    {
+                        "properties": [],
+                        "rollout_percentage": 99,
+                    },
+                    {
+                        "properties": [],
+                        "rollout_percentage": 99,
+                    },
+                    {
+                        "properties": [
+                            {
+                                "key": "name",
+                                "type": "person",
+                                "value": ["Smith"],
+                                "operator": "contains",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    },
+                ],
+            },
+        )
+
+        self.assert_expected_response(
+            boolean_flag_no_rolled_out_release_conditions.id,
+            FeatureFlagStatus.ACTIVE,
+        )
+
+        # Request status for boolean flag with a fully rolled out release condition
+        boolean_flag_rolled_out_release_condition = FeatureFlag.objects.create(
+            name="Boolean flag with a release condition set to 100%",
+            key="boolean-rolled-out-release-condition-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "name",
+                                "type": "person",
+                                "value": ["Smith"],
+                                "operator": "contains",
+                            }
+                        ],
+                        "rollout_percentage": 50,
+                    },
+                    {
+                        "properties": [],
+                        "rollout_percentage": 100,
+                    },
+                ],
+            },
+        )
+        self.assert_expected_response(
+            boolean_flag_rolled_out_release_condition.id,
+            FeatureFlagStatus.STALE,
+            'This boolean flag will always evaluate to "true"',
+        )
+
+        # Request status for a boolean flag with no rolled out release conditions and has
+        # been called recently
+        boolean_flag_no_rolled_out_release_condition_recently_evaluated = FeatureFlag.objects.create(
+            name="Boolean flag with a release condition set to 100%",
+            key="boolean-recently-evaluated-flag",
+            team=self.team,
+            active=True,
+            filters={
+                "groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "name",
+                                "type": "person",
+                                "value": ["Smith"],
+                                "operator": "contains",
+                            }
+                        ],
+                        "rollout_percentage": 50,
+                    },
+                ],
+            },
+        )
+
+        self.assert_expected_response(
+            boolean_flag_no_rolled_out_release_condition_recently_evaluated.id, FeatureFlagStatus.ACTIVE
+        )
diff --git a/posthog/api/test/test_hog_function.py b/posthog/api/test/test_hog_function.py
index 55788bb058191..b988b53fdbbfb 100644
--- a/posthog/api/test/test_hog_function.py
+++ b/posthog/api/test/test_hog_function.py
@@ -20,6 +20,7 @@
     "name": "HogHook",
     "hog": "fetch(inputs.url, {\n  'headers': inputs.headers,\n  'body': inputs.payload,\n  'method': inputs.method\n});",
     "type": "destination",
+    "enabled": True,
     "inputs_schema": [
         {"key": "url", "type": "string", "label": "Webhook URL", "required": True},
         {"key": "payload", "type": "json", "label": "JSON Payload", "required": True},
@@ -74,6 +75,7 @@ def _create_slack_function(self, data: Optional[dict] = None):
         payload = {
             "name": "Slack",
             "template_id": template_slack.id,
+            "type": "destination",
             "inputs": {
                 "slack_workspace": {"value": 1},
                 "channel": {"value": "#general"},
@@ -196,7 +198,13 @@ def _filter_expected_keys(self, actual_data, expected_structure):
     def test_create_hog_function(self, *args):
         response = self.client.post(
             f"/api/projects/{self.team.id}/hog_functions/",
-            data={"name": "Fetch URL", "description": "Test description", "hog": "fetch(inputs.url);", "inputs": {}},
+            data={
+                "type": "destination",
+                "name": "Fetch URL",
+                "description": "Test description",
+                "hog": "fetch(inputs.url);",
+                "inputs": {},
+            },
         )
         assert response.status_code == status.HTTP_201_CREATED, response.json()
         assert response.json()["created_by"]["id"] == self.user.id
@@ -218,6 +226,7 @@ def test_create_hog_function(self, *args):
             "icon_url": None,
             "template": None,
             "masking": None,
+            "mappings": None,
             "status": {"rating": 0, "state": 0, "tokens": 0},
         }
 
@@ -256,6 +265,7 @@ def test_creates_with_template_id(self, *args):
                 "description": "Test description",
                 "hog": "fetch(inputs.url);",
                 "template_id": template_webhook.id,
+                "type": "destination",
             },
         )
         assert response.status_code == status.HTTP_201_CREATED, response.json()
@@ -271,6 +281,8 @@ def test_creates_with_template_id(self, *args):
             "hog": template_webhook.hog,
             "filters": None,
             "masking": None,
+            "mappings": None,
+            "mapping_templates": None,
             "sub_templates": response.json()["template"]["sub_templates"],
         }
 
@@ -362,6 +374,7 @@ def test_inputs_required(self, *args):
             "inputs_schema": [
                 {"key": "url", "type": "string", "label": "Webhook URL", "required": True},
             ],
+            "type": "destination",
         }
         # Check required
         res = self.client.post(f"/api/projects/{self.team.id}/hog_functions/", data={**payload})
@@ -382,6 +395,7 @@ def test_inputs_mismatch_type(self, *args):
                 {"key": "dictionary", "type": "dictionary"},
                 {"key": "boolean", "type": "boolean"},
             ],
+            "type": "destination",
         }
 
         bad_inputs = {
@@ -414,6 +428,7 @@ def test_secret_inputs_not_returned(self, *args):
                     "value": "I AM SECRET",
                 },
             },
+            "type": "destination",
         }
         expectation = {
             "url": {
@@ -453,6 +468,7 @@ def test_secret_inputs_not_returned(self, *args):
 
     def test_secret_inputs_not_updated_if_not_changed(self, *args):
         payload = {
+            "type": "destination",
             "name": "Fetch URL",
             "hog": "fetch(inputs.url);",
             "inputs_schema": [
@@ -489,6 +505,7 @@ def test_secret_inputs_not_updated_if_not_changed(self, *args):
 
     def test_secret_inputs_updated_if_changed(self, *args):
         payload = {
+            "type": "destination",
             "name": "Fetch URL",
             "hog": "fetch(inputs.url);",
             "inputs_schema": [
@@ -580,6 +597,7 @@ def test_generates_hog_bytecode(self, *args):
         response = self.client.post(
             f"/api/projects/{self.team.id}/hog_functions/",
             data={
+                "type": "destination",
                 "name": "Fetch URL",
                 "hog": "let i := 0;\nwhile(i < 3) {\n  i := i + 1;\n  fetch(inputs.url, {\n    'headers': {\n      'x-count': f'{i}'\n    },\n    'body': inputs.payload,\n    'method': inputs.method\n  });\n}",
             },
@@ -790,13 +808,7 @@ def test_loads_status_when_enabled_and_available(self, *args):
 
             response = self.client.post(
                 f"/api/projects/{self.team.id}/hog_functions/",
-                data={
-                    "name": "Fetch URL",
-                    "description": "Test description",
-                    "hog": "fetch(inputs.url);",
-                    "template_id": template_webhook.id,
-                    "enabled": True,
-                },
+                data=EXAMPLE_FULL,
             )
             assert response.status_code == status.HTTP_201_CREATED, response.json()
 
@@ -810,13 +822,7 @@ def test_does_not_crash_when_status_not_available(self, *args):
 
             response = self.client.post(
                 f"/api/projects/{self.team.id}/hog_functions/",
-                data={
-                    "name": "Fetch URL",
-                    "description": "Test description",
-                    "hog": "fetch(inputs.url);",
-                    "template_id": template_webhook.id,
-                    "enabled": True,
-                },
+                data=EXAMPLE_FULL,
             )
             assert response.status_code == status.HTTP_201_CREATED, response.json()
             response = self.client.get(f"/api/projects/{self.team.id}/hog_functions/{response.json()['id']}")
@@ -830,7 +836,7 @@ def test_patches_status_on_enabled_update(self, *args):
 
                 response = self.client.post(
                     f"/api/projects/{self.team.id}/hog_functions/",
-                    data={"name": "Fetch URL", "hog": "fetch(inputs.url);", "enabled": True},
+                    data={"type": "destination", "name": "Fetch URL", "hog": "fetch(inputs.url);", "enabled": True},
                 )
                 id = response.json()["id"]
 
@@ -1055,6 +1061,30 @@ def test_create_hog_function_with_site_destination_type(self):
         assert response.json()["bytecode"] is None
         assert "Hello, site_destination" in response.json()["transpiled"]
 
+    def test_cannot_modify_type_of_existing_hog_function(self):
+        response = self.client.post(
+            f"/api/projects/{self.team.id}/hog_functions/",
+            data={
+                "name": "Site Destination Function",
+                "hog": "export function onLoad() { console.log('Hello, site_destination'); }",
+                "type": "site_destination",
+            },
+        )
+
+        assert response.status_code == status.HTTP_201_CREATED, response.json()
+
+        response = self.client.patch(
+            f"/api/projects/{self.team.id}/hog_functions/{response.json()['id']}/",
+            data={"type": "site_app"},
+        )
+        assert response.status_code == status.HTTP_400_BAD_REQUEST, response.json()
+        assert response.json() == {
+            "attr": "type",
+            "detail": "Cannot modify the type of an existing function",
+            "code": "invalid_input",
+            "type": "validation_error",
+        }
+
     def test_transpiled_field_not_populated_for_other_types(self):
         response = self.client.post(
             f"/api/projects/{self.team.id}/hog_functions/",
diff --git a/posthog/api/test/test_hog_function_templates.py b/posthog/api/test/test_hog_function_templates.py
index 956be4de638a9..7a9b5150f5acd 100644
--- a/posthog/api/test/test_hog_function_templates.py
+++ b/posthog/api/test/test_hog_function_templates.py
@@ -17,6 +17,8 @@
     "category": template.category,
     "filters": template.filters,
     "masking": template.masking,
+    "mappings": template.mappings,
+    "mapping_templates": template.mapping_templates,
     "icon_url": template.icon_url,
 }
 
diff --git a/posthog/api/test/test_organization.py b/posthog/api/test/test_organization.py
index 2396f78e3c557..143fbe3f524b9 100644
--- a/posthog/api/test/test_organization.py
+++ b/posthog/api/test/test_organization.py
@@ -1,4 +1,5 @@
 from rest_framework import status
+from unittest.mock import patch, ANY
 
 from posthog.models import Organization, OrganizationMembership, Team
 from posthog.models.personal_api_key import PersonalAPIKey, hash_key_value
@@ -128,7 +129,8 @@ def test_cant_update_plugins_access_level(self):
         self.organization.refresh_from_db()
         self.assertEqual(self.organization.plugins_access_level, 3)
 
-    def test_enforce_2fa_for_everyone(self):
+    @patch("posthoganalytics.capture")
+    def test_enforce_2fa_for_everyone(self, mock_capture):
         # Only admins should be able to enforce 2fa
         response = self.client.patch(f"/api/organizations/{self.organization.id}/", {"enforce_2fa": True})
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@@ -142,6 +144,19 @@ def test_enforce_2fa_for_everyone(self):
         self.organization.refresh_from_db()
         self.assertEqual(self.organization.enforce_2fa, True)
 
+        # Verify the capture event was called correctly
+        mock_capture.assert_any_call(
+            self.user.distinct_id,
+            "organization 2fa enforcement toggled",
+            properties={
+                "enabled": True,
+                "organization_id": str(self.organization.id),
+                "organization_name": self.organization.name,
+                "user_role": OrganizationMembership.Level.ADMIN,
+            },
+            groups={"instance": ANY, "organization": str(self.organization.id)},
+        )
+
     def test_projects_outside_personal_api_key_scoped_organizations_not_listed(self):
         other_org, _, _ = Organization.objects.bootstrap(self.user)
         personal_api_key = generate_random_token_personal()
diff --git a/posthog/api/test/test_organization_domain.py b/posthog/api/test/test_organization_domain.py
index 82ded3bc1c7fe..33de9f45facfc 100644
--- a/posthog/api/test/test_organization_domain.py
+++ b/posthog/api/test/test_organization_domain.py
@@ -1,5 +1,5 @@
 import datetime
-from unittest.mock import patch
+from unittest.mock import ANY, patch
 from zoneinfo import ZoneInfo
 
 import dns.resolver
@@ -84,7 +84,8 @@ def test_cannot_list_or_retrieve_domains_for_other_org(self):
 
     # Create domains
 
-    def test_create_domain(self):
+    @patch("posthoganalytics.capture")
+    def test_create_domain(self, mock_capture):
         self.organization_membership.level = OrganizationMembership.Level.ADMIN
         self.organization.available_product_features = [
             {"key": "automatic_provisioning", "name": "automatic_provisioning"}
@@ -116,6 +117,18 @@ def test_create_domain(self):
         self.assertEqual(instance.last_verification_retry, None)
         self.assertEqual(instance.sso_enforcement, "")
 
+        # Verify the domain creation capture event was called
+        mock_capture.assert_any_call(
+            self.user.distinct_id,
+            "organization domain created",
+            properties={
+                "domain": "the.posthog.com",
+                "jit_provisioning_enabled": False,
+                "sso_enforcement": None,
+            },
+            groups={"instance": ANY, "organization": str(self.organization.id)},
+        )
+
     def test_cant_create_domain_without_feature(self):
         self.organization_membership.level = OrganizationMembership.Level.ADMIN
         self.organization_membership.save()
@@ -439,7 +452,8 @@ def test_cannot_update_domain_for_another_org(self):
 
     # Delete domains
 
-    def test_admin_can_delete_domain(self):
+    @patch("posthoganalytics.capture")
+    def test_admin_can_delete_domain(self, mock_capture):
         self.organization_membership.level = OrganizationMembership.Level.ADMIN
         self.organization_membership.save()
 
@@ -449,6 +463,20 @@ def test_admin_can_delete_domain(self):
 
         self.assertFalse(OrganizationDomain.objects.filter(id=self.domain.id).exists())
 
+        # Verify the domain deletion capture event was called
+        mock_capture.assert_any_call(
+            self.user.distinct_id,
+            "organization domain deleted",
+            properties={
+                "domain": "myposthog.com",
+                "is_verified": False,
+                "had_saml": False,
+                "had_jit_provisioning": False,
+                "had_sso_enforcement": False,
+            },
+            groups={"instance": ANY, "organization": str(self.organization.id)},
+        )
+
     def test_only_admin_can_delete_domain(self):
         response = self.client.delete(f"/api/organizations/@current/domains/{self.domain.id}")
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
diff --git a/posthog/api/test/test_person.py b/posthog/api/test/test_person.py
index 2c9694f6eda6d..29eb3990407d5 100644
--- a/posthog/api/test/test_person.py
+++ b/posthog/api/test/test_person.py
@@ -873,7 +873,7 @@ def test_pagination_limit(self):
         create_person(team_id=self.team.pk, version=0)
 
         returned_ids = []
-        with self.assertNumQueries(10):
+        with self.assertNumQueries(9):
             response = self.client.get("/api/person/?limit=10").json()
         self.assertEqual(len(response["results"]), 9)
         returned_ids += [x["distinct_ids"][0] for x in response["results"]]
diff --git a/posthog/api/test/test_plugin.py b/posthog/api/test/test_plugin.py
index 0757ac6813c0a..8115ccabd45a9 100644
--- a/posthog/api/test/test_plugin.py
+++ b/posthog/api/test/test_plugin.py
@@ -1201,6 +1201,14 @@ def test_update_plugin_config_no_longer_globally_managed_but_still_enabled(self,
         )
         self.assertEqual(response.status_code, 200)
 
+    def test_retrieving_plugin_config_logs_empty(self, mock_get, mock_reload):
+        plugin = Plugin.objects.create(organization=self.organization)
+        plugin_config = PluginConfig.objects.create(plugin=plugin, enabled=True, team=self.team, order=0)
+
+        response = self.client.get(f"/api/environments/{self.team.pk}/plugin_configs/{plugin_config.id}/logs/")
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"count": 0, "next": None, "previous": None, "results": []})
+
     def test_delete_plugin_config_auth(self, mock_get, mock_reload):
         response = self.client.post(
             "/api/organizations/@current/plugins/",
diff --git a/posthog/api/test/test_remote_config.py b/posthog/api/test/test_remote_config.py
new file mode 100644
index 0000000000000..637030f5fe474
--- /dev/null
+++ b/posthog/api/test/test_remote_config.py
@@ -0,0 +1,141 @@
+from unittest.mock import patch
+from inline_snapshot import snapshot
+from rest_framework import status
+from django.core.cache import cache
+
+from posthog.test.base import APIBaseTest, FuzzyInt, QueryMatchingTest
+
+# The remote config stuff plus plugin and hog function queries
+CONFIG_REFRESH_QUERY_COUNT = 5
+
+
+class TestRemoteConfig(APIBaseTest, QueryMatchingTest):
+    def setUp(self):
+        self.client.logout()
+
+        self.team.recording_domains = ["https://*.example.com"]
+        self.team.session_recording_opt_in = True
+        self.team.save()
+
+        cache.clear()
+
+    def test_missing_tokens(self):
+        with self.assertNumQueries(1):
+            response = self.client.get("/array/missing/config")
+            assert response.status_code == status.HTTP_404_NOT_FOUND
+
+        with self.assertNumQueries(0):
+            response = self.client.get("/array/missing/config")
+            assert response.status_code == status.HTTP_404_NOT_FOUND
+
+    def test_invalid_tokens(self):
+        response = self.client.get("/array/§$%$&/config")
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert response.json()["detail"] == "Invalid token"
+
+        response = self.client.get("/array/I-am_technically_v4lid/config")
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+
+    def test_valid_config(self):
+        # Not sure why but there is sometimes one extra query here
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            response = self.client.get(f"/array/{self.team.api_token}/config", HTTP_ORIGIN="https://foo.example.com")
+
+        with self.assertNumQueries(0):
+            response = self.client.get(f"/array/{self.team.api_token}/config", HTTP_ORIGIN="https://foo.example.com")
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.headers["Content-Type"] == "application/json"
+        assert response.json() == snapshot(
+            {
+                "token": "token123",
+                "supportedCompression": ["gzip", "gzip-js"],
+                "hasFeatureFlags": False,
+                "captureDeadClicks": False,
+                "capturePerformance": {"network_timing": True, "web_vitals": False, "web_vitals_allowed_metrics": None},
+                "autocapture_opt_out": False,
+                "autocaptureExceptions": False,
+                "analytics": {"endpoint": "/i/v0/e/"},
+                "elementsChainAsString": True,
+                "sessionRecording": {
+                    "endpoint": "/s/",
+                    "consoleLogRecordingEnabled": True,
+                    "recorderVersion": "v2",
+                    "sampleRate": None,
+                    "minimumDurationMilliseconds": None,
+                    "linkedFlag": None,
+                    "networkPayloadCapture": None,
+                    "urlTriggers": [],
+                    "urlBlocklist": [],
+                    "eventTriggers": [],
+                    "scriptConfig": None,
+                },
+                "surveys": [],
+                "heatmaps": False,
+                "defaultIdentifiedOnly": True,
+                "siteApps": [],
+            }
+        )
+
+    def test_vary_header_response(self):
+        response = self.client.get(f"/array/{self.team.api_token}/config", HTTP_ORIGIN="https://foo.example.com")
+        assert response.status_code == status.HTTP_200_OK, response.json()
+        assert "Origin" in response.headers["Vary"]
+        assert "Referer" in response.headers["Vary"]
+
+    def test_different_response_for_other_domains(self):
+        # Not sure why but there is sometimes one extra query here
+        with self.assertNumQueries(FuzzyInt(CONFIG_REFRESH_QUERY_COUNT, CONFIG_REFRESH_QUERY_COUNT + 1)):
+            response = self.client.get(f"/array/{self.team.api_token}/config", HTTP_ORIGIN="https://foo.example.com")
+            assert response.status_code == status.HTTP_200_OK, response.json()
+            assert response.json()["sessionRecording"]
+
+        with self.assertNumQueries(0):
+            response = self.client.get(f"/array/{self.team.api_token}/config", HTTP_ORIGIN="https://foo.example.com")
+            assert response.status_code == status.HTTP_200_OK, response.json()
+            assert response.json()["sessionRecording"]
+
+        with self.assertNumQueries(0):
+            response = self.client.get(f"/array/{self.team.api_token}/config", HTTP_ORIGIN="https://bar.other.com")
+            assert response.status_code == status.HTTP_200_OK, response.json()
+            assert not response.json()["sessionRecording"]
+
+    def test_valid_config_js(self):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            response = self.client.get(f"/array/{self.team.api_token}/config.js", HTTP_ORIGIN="https://foo.example.com")
+
+        with self.assertNumQueries(0):
+            response = self.client.get(f"/array/{self.team.api_token}/config.js", HTTP_ORIGIN="https://foo.example.com")
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.headers["Content-Type"] == "application/javascript"
+
+        assert response.content == snapshot(
+            b'(function() {\n  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {};\n  window._POSTHOG_REMOTE_CONFIG[\'token123\'] = {\n    config: {"token": "token123", "supportedCompression": ["gzip", "gzip-js"], "hasFeatureFlags": false, "captureDeadClicks": false, "capturePerformance": {"network_timing": true, "web_vitals": false, "web_vitals_allowed_metrics": null}, "autocapture_opt_out": false, "autocaptureExceptions": false, "analytics": {"endpoint": "/i/v0/e/"}, "elementsChainAsString": true, "sessionRecording": {"endpoint": "/s/", "consoleLogRecordingEnabled": true, "recorderVersion": "v2", "sampleRate": null, "minimumDurationMilliseconds": null, "linkedFlag": null, "networkPayloadCapture": null, "urlTriggers": [], "urlBlocklist": [], "eventTriggers": [], "scriptConfig": null}, "heatmaps": false, "surveys": [], "defaultIdentifiedOnly": true},\n    siteApps: []\n  }\n})();'
+        )
+
+    @patch("posthog.models.remote_config.get_array_js_content", return_value="[MOCKED_ARRAY_JS_CONTENT]")
+    def test_valid_array_js(self, mock_get_array_js_content):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            response = self.client.get(f"/array/{self.team.api_token}/array.js", HTTP_ORIGIN="https://foo.example.com")
+
+        with self.assertNumQueries(0):
+            response = self.client.get(f"/array/{self.team.api_token}/array.js", HTTP_ORIGIN="https://foo.example.com")
+        assert response.status_code == status.HTTP_200_OK
+        assert response.headers["Content-Type"] == "application/javascript"
+        assert response.content
+
+        assert response.content == snapshot(
+            b'[MOCKED_ARRAY_JS_CONTENT]\n\n(function() {\n  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {};\n  window._POSTHOG_REMOTE_CONFIG[\'token123\'] = {\n    config: {"token": "token123", "supportedCompression": ["gzip", "gzip-js"], "hasFeatureFlags": false, "captureDeadClicks": false, "capturePerformance": {"network_timing": true, "web_vitals": false, "web_vitals_allowed_metrics": null}, "autocapture_opt_out": false, "autocaptureExceptions": false, "analytics": {"endpoint": "/i/v0/e/"}, "elementsChainAsString": true, "sessionRecording": {"endpoint": "/s/", "consoleLogRecordingEnabled": true, "recorderVersion": "v2", "sampleRate": null, "minimumDurationMilliseconds": null, "linkedFlag": null, "networkPayloadCapture": null, "urlTriggers": [], "urlBlocklist": [], "eventTriggers": [], "scriptConfig": null}, "heatmaps": false, "surveys": [], "defaultIdentifiedOnly": true},\n    siteApps: []\n  }\n})();'
+        )
+
+        # NOT actually testing the content here as it will change dynamically
+
+    @patch("posthog.models.remote_config.get_array_js_content", return_value="[MOCKED_ARRAY_JS_CONTENT]")
+    def test_valid_array_uses_config_js_cache(self, mock_get_array_js_content):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            response = self.client.get(f"/array/{self.team.api_token}/config.js", HTTP_ORIGIN="https://foo.example.com")
+
+        with self.assertNumQueries(0):
+            response = self.client.get(f"/array/{self.team.api_token}/array.js", HTTP_ORIGIN="https://foo.example.com")
+        assert response.status_code == status.HTTP_200_OK
diff --git a/posthog/api/test/test_site_app.py b/posthog/api/test/test_site_app.py
index 23408defe752f..92340e67144bd 100644
--- a/posthog/api/test/test_site_app.py
+++ b/posthog/api/test/test_site_app.py
@@ -2,7 +2,7 @@
 from rest_framework import status
 
 from posthog.api.site_app import get_site_config_from_schema
-from posthog.models import Plugin, PluginConfig, PluginSourceFile, HogFunction
+from posthog.models import Plugin, PluginConfig, PluginSourceFile
 from posthog.test.base import BaseTest
 
 
@@ -82,32 +82,3 @@ def test_get_site_config_from_schema(self):
         config = {"in_site": "123", "not_in_site": "12345"}
         self.assertEqual(get_site_config_from_schema(schema, config), {"in_site": "123"})
         self.assertEqual(get_site_config_from_schema(None, None), {})
-
-    def test_site_function(self):
-        # Create a HogFunction object
-        hog_function = HogFunction.objects.create(
-            enabled=True,
-            team=self.team,
-            type="site_app",
-            transpiled="function test() {}",
-        )
-
-        response = self.client.get(
-            f"/site_function/{hog_function.id}/somehash/",
-            HTTP_ORIGIN="http://127.0.0.1:8000",
-        )
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.content.decode("utf-8"), hog_function.transpiled)
-        self.assertEqual(response["Cache-Control"], "public, max-age=31536000")
-
-    def test_site_function_not_found(self):
-        response = self.client.get(
-            f"/site_function/non-existent-id/somehash/",
-            HTTP_ORIGIN="http://127.0.0.1:8000",
-        )
-
-        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
-        response_json = response.json()
-        self.assertEqual(response_json["code"], "missing_site_function_source")
-        self.assertEqual(response_json["detail"], "Unable to serve site function source code.")
diff --git a/posthog/api/test/test_survey.py b/posthog/api/test/test_survey.py
index 0c79b33518c7b..35b0bb1cdc553 100644
--- a/posthog/api/test/test_survey.py
+++ b/posthog/api/test/test_survey.py
@@ -2378,6 +2378,7 @@ def test_can_clear_associated_actions(self):
         assert len(survey.actions.all()) == 0
 
 
+@freeze_time("2024-12-12 00:00:00")
 class TestSurveyResponseSampling(APIBaseTest):
     def _create_survey_with_sampling_limits(
         self,
@@ -2407,6 +2408,7 @@ def _create_survey_with_sampling_limits(
         )
 
         response_data = response.json()
+        assert response.status_code == status.HTTP_201_CREATED, response_data
         survey = Survey.objects.get(id=response_data["id"])
         return survey
 
@@ -2783,9 +2785,6 @@ def test_list_surveys_with_actions(self):
                                     {
                                         "id": action.id,
                                         "name": "user subscribed",
-                                        "description": "",
-                                        "post_to_slack": False,
-                                        "slack_message_format": "",
                                         "steps": [
                                             {
                                                 "event": "$pageview",
@@ -2800,17 +2799,6 @@ def test_list_surveys_with_actions(self):
                                                 "url_matching": "contains",
                                             }
                                         ],
-                                        "created_at": ANY,
-                                        "created_by": None,
-                                        "deleted": False,
-                                        "is_calculating": False,
-                                        "creation_context": None,
-                                        "last_calculated_at": ANY,
-                                        "team_id": self.team.id,
-                                        "is_action": True,
-                                        "bytecode_error": None,
-                                        "pinned_at": None,
-                                        "tags": [],
                                     }
                                 ]
                             }
@@ -2921,8 +2909,7 @@ def test_list_surveys_excludes_description(self):
             for survey in surveys:
                 assert "description" not in survey, f"Description field should not be present in survey: {survey}"
 
-            assert surveys[0]["name"] == "Survey 1"
-            assert surveys[1]["name"] == "Survey 2"
+            assert len(surveys) == 2
 
 
 class TestSurveyAPITokens(PersonalAPIKeysBaseTest, APIBaseTest):
diff --git a/posthog/api/test/test_team.py b/posthog/api/test/test_team.py
index 0040ddd257e2d..1da488504f57d 100644
--- a/posthog/api/test/test_team.py
+++ b/posthog/api/test/test_team.py
@@ -16,6 +16,7 @@
 from posthog.models import ActivityLog, EarlyAccessFeature
 from posthog.models.async_deletion.async_deletion import AsyncDeletion, DeletionType
 from posthog.models.dashboard import Dashboard
+from posthog.models.group_type_mapping import GroupTypeMapping
 from posthog.models.instance_setting import get_instance_setting
 from posthog.models.organization import Organization, OrganizationMembership
 from posthog.models.personal_api_key import PersonalAPIKey, hash_key_value
@@ -87,6 +88,26 @@ def test_retrieve_team(self):
             self.assertNotIn("event_names_with_usage", response_data)
             self.assertNotIn("event_properties_with_usage", response_data)
 
+        def test_retrieve_team_has_group_types(self):
+            other_team = Team.objects.create(organization=self.organization, project=self.project)
+
+            response = self.client.get("/api/environments/@current/")
+            response_data = response.json()
+
+            self.assertEqual(response.status_code, status.HTTP_200_OK, response_data)
+            self.assertEqual(response_data["has_group_types"], False)
+
+            # Creating a group type in the same project, but different team
+            GroupTypeMapping.objects.create(
+                project=self.project, team=other_team, group_type="person", group_type_index=0
+            )
+
+            response = self.client.get("/api/environments/@current/")
+            response_data = response.json()
+
+            self.assertEqual(response.status_code, status.HTTP_200_OK, response_data)
+            self.assertEqual(response_data["has_group_types"], True)  # Irreleveant that group type has different `team`
+
         def test_cant_retrieve_team_from_another_org(self):
             org = Organization.objects.create(name="New Org")
             team = Team.objects.create(organization=org, name="Default project")
@@ -1052,7 +1073,7 @@ def test_can_add_product_intent(
             )
 
         @patch("posthog.api.team.calculate_product_activation.delay", MagicMock())
-        @patch("posthog.models.product_intent.ProductIntent.check_and_update_activation")
+        @patch("posthog.models.product_intent.ProductIntent.check_and_update_activation", return_value=False)
         @patch("posthog.api.project.report_user_action")
         @patch("posthog.api.team.report_user_action")
         @freeze_time("2024-01-01T00:00:00Z")
@@ -1062,6 +1083,10 @@ def test_can_update_product_intent_if_already_exists(
             mock_report_user_action_legacy_endpoint: MagicMock,
             mock_check_and_update_activation: MagicMock,
         ) -> None:
+            """
+            Intent already exists, but hasn't been activated yet. It should update the intent
+            and send a new event for the user showing the intent.
+            """
             intent = ProductIntent.objects.create(team=self.team, product_type="product_analytics")
             original_created_at = intent.created_at
             assert original_created_at == datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
diff --git a/posthog/api/test/test_user.py b/posthog/api/test/test_user.py
index 1c9d3b96aec04..0d60d7c9c4992 100644
--- a/posthog/api/test/test_user.py
+++ b/posthog/api/test/test_user.py
@@ -18,6 +18,8 @@
 from posthog.models.instance_setting import set_instance_setting
 from posthog.models.organization import Organization, OrganizationMembership
 from posthog.test.base import APIBaseTest
+from django_otp.plugins.otp_static.models import StaticDevice
+from django_otp.plugins.otp_totp.models import TOTPDevice
 
 
 def create_user(email: str, password: str, organization: Organization):
@@ -417,7 +419,7 @@ def test_notifications_sent_when_user_email_is_changed_and_email_available(
             token = email_verification_token_generator.make_token(self.user)
             with freeze_time("2020-01-01T21:37:00+00:00"):
                 response = self.client.post(
-                    f"/api/users/@me/verify_email/",
+                    f"/api/users/verify_email/",
                     {"uuid": self.user.uuid, "token": token},
                 )
             self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -1040,7 +1042,7 @@ def test_only_staff_user_can_update_staff_prop(self):
     def test_add_2fa(self, patch_is_valid):
         patch_is_valid.return_value = Mock()
         self._create_user("newuser@posthog.com", password="12345678")
-        response = self.client.get(f"/api/users/@me/start_2fa_setup/")
+        response = self.client.get(f"/api/users/@me/two_factor_start_setup/")
         response = self.client.post(f"/api/users/@me/validate_2fa/", {"token": 123456})
         self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)
 
@@ -1052,7 +1054,13 @@ def setUp(self):
         # prevent throttling of user requests to pass on from one test
         # to the next
         cache.clear()
-        return super().setUp()
+        super().setUp()
+
+        set_instance_setting("EMAIL_HOST", "localhost")
+
+        self.other_user = self._create_user("otheruser@posthog.com", password="12345678")
+        assert not self.other_user.is_email_verified
+        assert not self.other_user.is_email_verified
 
     # Email verification request
 
@@ -1060,7 +1068,7 @@ def setUp(self):
     def test_user_can_request_verification_email(self, mock_capture):
         set_instance_setting("EMAIL_HOST", "localhost")
         with self.settings(CELERY_TASK_ALWAYS_EAGER=True, SITE_URL="https://my.posthog.net"):
-            response = self.client.post(f"/api/users/@me/request_email_verification/", {"uuid": self.user.uuid})
+            response = self.client.post(f"/api/users/request_email_verification/", {"uuid": self.user.uuid})
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.content.decode(), '{"success":true}')
         self.assertSetEqual({",".join(outmail.to) for outmail in mail.outbox}, {self.CONFIG_EMAIL})
@@ -1078,7 +1086,7 @@ def test_user_can_request_verification_email(self, mock_capture):
         reset_link = html_message[link_index : html_message.find('"', link_index)]
         token = reset_link.replace("https://my.posthog.net/verify_email/", "").replace(f"{self.user.uuid}/", "")
 
-        response = self.client.post(f"/api/users/@me/verify_email/", {"uuid": self.user.uuid, "token": token})
+        response = self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": token})
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
         # check is_email_verified is changed to True
@@ -1112,8 +1120,9 @@ def test_user_can_request_verification_email(self, mock_capture):
         self.assertEqual(mock_capture.call_count, 3)
 
     def test_cant_verify_if_email_is_not_configured(self):
+        set_instance_setting("EMAIL_HOST", "")
         with self.settings(CELERY_TASK_ALWAYS_EAGER=True):
-            response = self.client.post(f"/api/users/@me/request_email_verification/", {"uuid": self.user.uuid})
+            response = self.client.post(f"/api/users/request_email_verification/", {"uuid": self.user.uuid})
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(
             response.json(),
@@ -1131,7 +1140,7 @@ def test_cant_verify_more_than_six_times(self):
         for i in range(7):
             with self.settings(CELERY_TASK_ALWAYS_EAGER=True, SITE_URL="https://my.posthog.net"):
                 response = self.client.post(
-                    f"/api/users/@me/request_email_verification/",
+                    f"/api/users/request_email_verification/",
                     {"uuid": self.user.uuid},
                 )
             if i < 6:
@@ -1151,11 +1160,11 @@ def test_cant_verify_more_than_six_times(self):
 
     def test_can_validate_email_verification_token(self):
         token = email_verification_token_generator.make_token(self.user)
-        response = self.client.post(f"/api/users/@me/verify_email/", {"uuid": self.user.uuid, "token": token})
+        response = self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": token})
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
     def test_cant_validate_email_verification_token_without_a_token(self):
-        response = self.client.post(f"/api/users/@me/verify_email/", {"uuid": self.user.uuid})
+        response = self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid})
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(
             response.json(),
@@ -1181,7 +1190,7 @@ def test_invalid_verification_token_returns_error(self):
             expired_token,
         ]:
             response = self.client.post(
-                f"/api/users/@me/verify_email/",
+                f"/api/users/verify_email/",
                 {"uuid": self.user.uuid, "token": token},
             )
             self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
@@ -1194,3 +1203,228 @@ def test_invalid_verification_token_returns_error(self):
                     "attr": "token",
                 },
             )
+
+    def test_can_only_validate_email_token_one_time(self):
+        token = email_verification_token_generator.make_token(self.user)
+        response = self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": token})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        response = self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": token})
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.json(),
+            {
+                "type": "validation_error",
+                "code": "invalid_token",
+                "detail": "This verification token is invalid or has expired.",
+                "attr": "token",
+            },
+        )
+
+    def test_email_verification_logs_in_user(self):
+        token = email_verification_token_generator.make_token(self.user)
+
+        self.client.logout()
+        assert self.client.get("/api/users/@me/").status_code == 401
+        session_user_id = self.client.session.get("_auth_user_id")
+        assert session_user_id is None
+
+        # NOTE: Posting sets the session user id but doesn't log in the test client hence we just check the session id
+        self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": token})
+        session_user_id = self.client.session.get("_auth_user_id")
+        assert session_user_id == str(self.user.id)
+
+    def test_email_verification_logs_in_correctuser(self):
+        other_token = email_verification_token_generator.make_token(self.other_user)
+        self.client.logout()
+        assert self.client.session.get("_auth_user_id") is None
+
+        # NOTE: The user id in path should basically be ignored
+        self.client.post(f"/api/users/verify_email/", {"uuid": self.other_user.uuid, "token": other_token})
+        session_user_id = self.client.session.get("_auth_user_id")
+        assert session_user_id == str(self.other_user.id)
+
+    def test_email_verification_does_not_apply_to_current_logged_in_user(self):
+        other_token = email_verification_token_generator.make_token(self.other_user)
+
+        res = self.client.post(f"/api/users/verify_email/", {"uuid": self.other_user.uuid, "token": other_token})
+        assert res.status_code == status.HTTP_200_OK
+        self.user.refresh_from_db()
+        self.other_user.refresh_from_db()
+        # Should now be logged in as other user
+        assert self.client.session.get("_auth_user_id") == str(self.other_user.id)
+        assert not self.user.is_email_verified
+        assert self.other_user.is_email_verified
+
+    def test_email_verification_fails_if_using_other_accounts_token(self):
+        token = email_verification_token_generator.make_token(self.user)
+        other_token = email_verification_token_generator.make_token(self.other_user)
+        self.client.logout()
+
+        assert (
+            self.client.post(f"/api/users/verify_email/", {"uuid": self.other_user.uuid, "token": token}).status_code
+            == status.HTTP_400_BAD_REQUEST
+        )
+
+        assert (
+            self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": other_token}).status_code
+            == status.HTTP_400_BAD_REQUEST
+        )
+
+    def test_does_not_apply_pending_email_for_old_tokens(self):
+        self.client.logout()
+
+        token = email_verification_token_generator.make_token(self.user)
+        self.user.pending_email = "new@posthog.com"
+        self.user.save()
+
+        response = self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": token})
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert self.user.email != "new@posthog.com"
+        assert self.user.pending_email == "new@posthog.com"
+
+        token = email_verification_token_generator.make_token(self.user)
+        response = self.client.post(f"/api/users/verify_email/", {"uuid": self.user.uuid, "token": token})
+        assert response.status_code == status.HTTP_200_OK
+        self.user.refresh_from_db()
+        assert self.user.email == "new@posthog.com"
+        assert self.user.pending_email is None
+
+
+class TestUserTwoFactor(APIBaseTest):
+    def setUp(self):
+        super().setUp()
+        # prevent throttling of user requests to pass on from one test
+        # to the next
+        cache.clear()
+
+    @patch("posthog.api.user.TOTPDeviceForm")
+    def test_two_factor_start_setup(self, mock_totp_form):
+        response = self.client.get(f"/api/users/@me/two_factor_start_setup/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.json(), {"success": True})
+
+        # Verify session contains required keys
+        self.assertIn("django_two_factor-hex", self.client.session)
+        self.assertIn("django_two_factor-qr_secret_key", self.client.session)
+        self.assertEqual(len(self.client.session["django_two_factor-hex"]), 40)  # 20 bytes hex = 40 chars
+
+    @patch("posthog.api.user.TOTPDeviceForm")
+    def test_two_factor_validation_with_valid_token(self, mock_totp_form):
+        # Setup form mock
+        mock_form_instance = mock_totp_form.return_value
+        mock_form_instance.is_valid.return_value = True
+
+        # Setup session state
+        session = self.client.session
+        session["django_two_factor-hex"] = "1234567890abcdef1234"
+        session.save()
+
+        response = self.client.post(f"/api/users/@me/two_factor_validate/", {"token": "123456"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.json(), {"success": True})
+
+        # Verify form was created with correct params
+        mock_totp_form.assert_called_once_with("1234567890abcdef1234", self.user, data={"token": "123456"})
+        mock_form_instance.save.assert_called_once()
+
+    @patch("posthog.api.user.TOTPDeviceForm")
+    def test_two_factor_validation_with_invalid_token(self, mock_totp_form):
+        # Setup form mock to fail validation
+        mock_form_instance = mock_totp_form.return_value
+        mock_form_instance.is_valid.return_value = False
+
+        # Setup session state
+        session = self.client.session
+        session["django_two_factor-hex"] = "1234567890abcdef1234"
+        session.save()
+
+        response = self.client.post(f"/api/users/@me/two_factor_validate/", {"token": "invalid"})
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.json(),
+            {
+                "type": "validation_error",
+                "code": "token_invalid",
+                "detail": "Token is not valid",
+                "attr": None,
+            },
+        )
+
+    def test_two_factor_status_when_disabled(self):
+        response = self.client.get(f"/api/users/@me/two_factor_status/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            response.json(),
+            {
+                "is_enabled": False,
+                "backup_codes": [],
+                "method": None,
+            },
+        )
+
+    @patch("posthog.api.user.default_device")
+    def test_two_factor_status_when_enabled(self, mock_default_device):
+        # Mock TOTP device
+        totp_device = TOTPDevice.objects.create(user=self.user, name="default")
+        mock_default_device.return_value = totp_device
+
+        # Create backup codes
+        static_device = StaticDevice.objects.create(user=self.user, name="backup")
+        static_device.token_set.create(token="123456")
+        static_device.token_set.create(token="789012")
+
+        response = self.client.get(f"/api/users/@me/two_factor_status/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            response.json(),
+            {
+                "is_enabled": True,
+                "backup_codes": ["123456", "789012"],
+                "method": "TOTP",
+            },
+        )
+
+    @patch("posthog.api.user.default_device")
+    def test_two_factor_backup_codes_generation(self, mock_default_device):
+        # Mock TOTP device to simulate 2FA being enabled
+        totp_device = TOTPDevice.objects.create(user=self.user, name="default")
+        mock_default_device.return_value = totp_device
+
+        response = self.client.post(f"/api/users/@me/two_factor_backup_codes/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        backup_codes = response.json()["backup_codes"]
+        self.assertEqual(len(backup_codes), 5)  # Verify 5 backup codes are generated
+
+        # Verify codes are stored in database
+        static_device = StaticDevice.objects.get(user=self.user)
+        stored_codes = [token.token for token in static_device.token_set.all()]
+        self.assertEqual(sorted(backup_codes), sorted(stored_codes))
+
+    def test_two_factor_backup_codes_requires_2fa_enabled(self):
+        response = self.client.post(f"/api/users/@me/two_factor_backup_codes/")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            response.json(),
+            {
+                "type": "validation_error",
+                "code": "2fa_not_enabled",
+                "detail": "2FA must be enabled first",
+                "attr": None,
+            },
+        )
+
+    def test_two_factor_disable(self):
+        # Setup 2FA devices
+        TOTPDevice.objects.create(user=self.user, name="default")
+        static_device = StaticDevice.objects.create(user=self.user, name="backup")
+        static_device.token_set.create(token="123456")
+
+        response = self.client.post(f"/api/users/@me/two_factor_disable/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.json(), {"success": True})
+
+        # Verify all 2FA devices are removed
+        self.assertEqual(TOTPDevice.objects.filter(user=self.user).count(), 0)
+        self.assertEqual(StaticDevice.objects.filter(user=self.user).count(), 0)
diff --git a/posthog/api/user.py b/posthog/api/user.py
index 737f507d3f635..0610abf047df7 100644
--- a/posthog/api/user.py
+++ b/posthog/api/user.py
@@ -382,32 +382,11 @@ def get_serializer_context(self):
             "user_permissions": UserPermissions(cast(User, self.request.user)),
         }
 
-    @action(methods=["GET"], detail=True)
-    def start_2fa_setup(self, request, **kwargs):
-        key = random_hex(20)
-        self.request.session["django_two_factor-hex"] = key
-        rawkey = unhexlify(key.encode("ascii"))
-        b32key = b32encode(rawkey).decode("utf-8")
-        self.request.session["django_two_factor-qr_secret_key"] = b32key
-        return Response({"success": True})
-
-    @action(methods=["POST"], detail=True)
-    def validate_2fa(self, request, **kwargs):
-        form = TOTPDeviceForm(
-            request.session["django_two_factor-hex"],
-            request.user,
-            data={"token": request.data["token"]},
-        )
-        if not form.is_valid():
-            raise serializers.ValidationError("Token is not valid", code="token_invalid")
-        form.save()
-        otp_login(request, default_device(request.user))
-        return Response({"success": True})
-
-    @action(methods=["POST"], detail=True, permission_classes=[AllowAny])
+    @action(methods=["POST"], detail=False, permission_classes=[AllowAny])
     def verify_email(self, request, **kwargs):
         token = request.data["token"] if "token" in request.data else None
         user_uuid = request.data["uuid"]
+
         if not token:
             raise serializers.ValidationError({"token": ["This field is required."]}, code="required")
 
@@ -443,7 +422,7 @@ def verify_email(self, request, **kwargs):
 
     @action(
         methods=["POST"],
-        detail=True,
+        detail=False,
         permission_classes=[AllowAny],
         throttle_classes=[UserEmailVerificationThrottle],
     )
@@ -489,6 +468,38 @@ def hedgehog_config(self, request, **kwargs):
             instance.save()
             return Response(instance.hedgehog_config)
 
+    # Deprecated - use two_factor_start_setup instead
+    @action(methods=["GET"], detail=True)
+    def start_2fa_setup(self, request, **kwargs):
+        return self.two_factor_start_setup(request, **kwargs)
+
+    @action(methods=["GET"], detail=True)
+    def two_factor_start_setup(self, request, **kwargs):
+        key = random_hex(20)
+        self.request.session["django_two_factor-hex"] = key
+        rawkey = unhexlify(key.encode("ascii"))
+        b32key = b32encode(rawkey).decode("utf-8")
+        self.request.session["django_two_factor-qr_secret_key"] = b32key
+        return Response({"success": True})
+
+    # Deprecated - use two_factor_validate instead
+    @action(methods=["POST"], detail=True)
+    def validate_2fa(self, request, **kwargs):
+        return self.two_factor_validate(request, **kwargs)
+
+    @action(methods=["POST"], detail=True)
+    def two_factor_validate(self, request, **kwargs):
+        form = TOTPDeviceForm(
+            request.session["django_two_factor-hex"],
+            request.user,
+            data={"token": request.data["token"]},
+        )
+        if not form.is_valid():
+            raise serializers.ValidationError("Token is not valid", code="token_invalid")
+        form.save()
+        otp_login(request, default_device(request.user))
+        return Response({"success": True})
+
     @action(methods=["GET"], detail=True)
     def two_factor_status(self, request, **kwargs):
         """Get current 2FA status including backup codes if enabled"""
@@ -526,7 +537,7 @@ def two_factor_backup_codes(self, request, **kwargs):
 
         # Generate new backup codes
         backup_codes = []
-        for _ in range(10):  # Generate 10 backup codes
+        for _ in range(5):  # Generate 5 backup codes
             token = StaticToken.random_token()
             static_device.token_set.create(token=token)
             backup_codes.append(token)
diff --git a/posthog/api/utils.py b/posthog/api/utils.py
index 514534990a8f0..79c4c1028d1d2 100644
--- a/posthog/api/utils.py
+++ b/posthog/api/utils.py
@@ -1,4 +1,5 @@
 import json
+from django.http import HttpRequest
 from rest_framework.decorators import action as drf_action
 from functools import wraps
 from posthog.api.documentation import extend_schema
@@ -427,6 +428,25 @@ def parse_domain(url: Any) -> Optional[str]:
     return urlparse(url).hostname
 
 
+def on_permitted_recording_domain(permitted_domains: list[str], request: HttpRequest) -> bool:
+    origin = parse_domain(request.headers.get("Origin"))
+    referer = parse_domain(request.headers.get("Referer"))
+
+    user_agent = request.META.get("HTTP_USER_AGENT")
+
+    is_authorized_web_client: bool = hostname_in_allowed_url_list(
+        permitted_domains, origin
+    ) or hostname_in_allowed_url_list(permitted_domains, referer)
+    # TODO this is a short term fix for beta testers
+    # TODO we will match on the app identifier in the origin instead and allow users to auth those
+    is_authorized_mobile_client: bool = user_agent is not None and any(
+        keyword in user_agent
+        for keyword in ["posthog-android", "posthog-ios", "posthog-react-native", "posthog-flutter"]
+    )
+
+    return is_authorized_web_client or is_authorized_mobile_client
+
+
 # By default, DRF spectacular uses the serializer of the view as the response format for actions. However, most actions don't return a version of the model, but something custom. This function removes the response from all actions in the documentation.
 def action(methods=None, detail=None, url_path=None, url_name=None, responses=None, **kwargs):
     """
diff --git a/posthog/batch_exports/service.py b/posthog/batch_exports/service.py
index 59b217b4fc8f2..d17bb3b1b69c3 100644
--- a/posthog/batch_exports/service.py
+++ b/posthog/batch_exports/service.py
@@ -794,3 +794,19 @@ async def aupdate_batch_export_backfill_status(backfill_id: UUID, status: str) -
         raise ValueError(f"BatchExportBackfill with id {backfill_id} not found.")
 
     return await model.aget()
+
+
+async def aupdate_records_total_count(
+    batch_export_id: UUID, interval_start: dt.datetime, interval_end: dt.datetime, count: int
+) -> int:
+    """Update the expected records count for a set of batch export runs.
+
+    Typically, there is one batch export run per batch export interval, however
+    there could be multiple if data has been backfilled.
+    """
+    rows_updated = await BatchExportRun.objects.filter(
+        batch_export_id=batch_export_id,
+        data_interval_start=interval_start,
+        data_interval_end=interval_end,
+    ).aupdate(records_total_count=count)
+    return rows_updated
diff --git a/posthog/batch_exports/sql.py b/posthog/batch_exports/sql.py
index baa0216afdbbc..9a7fd0cea95aa 100644
--- a/posthog/batch_exports/sql.py
+++ b/posthog/batch_exports/sql.py
@@ -318,3 +318,22 @@
     SETTINGS optimize_aggregation_in_order=1
 )
 """
+
+# TODO: is this the best query to use?
+EVENT_COUNT_BY_INTERVAL = """
+SELECT
+    toStartOfInterval(_inserted_at, INTERVAL {interval}) AS interval_start,
+    interval_start + INTERVAL {interval} AS interval_end,
+    COUNT(*) as total_count
+FROM
+    events_batch_export_recent(
+        team_id={team_id},
+        interval_start={overall_interval_start},
+        interval_end={overall_interval_end},
+        include_events={include_events}::Array(String),
+        exclude_events={exclude_events}::Array(String)
+    ) AS events
+GROUP BY interval_start
+ORDER BY interval_start desc
+SETTINGS max_replica_delay_for_distributed_queries=1
+"""
diff --git a/posthog/cdp/filters.py b/posthog/cdp/filters.py
index f95d3f029a0f3..b3ea85d49f45b 100644
--- a/posthog/cdp/filters.py
+++ b/posthog/cdp/filters.py
@@ -43,7 +43,7 @@ def hog_function_filters_to_expr(filters: dict, team: Team, actions: dict[int, A
                 action_id = int(filter["id"])
                 action = actions.get(action_id, None)
                 if not action:
-                    action = Action.objects.get(id=action_id, team=team)
+                    action = Action.objects.get(id=action_id, team__project_id=team.project_id)
                 exprs.append(action_to_expr(action))
             except KeyError:
                 # If an action doesn't exist, we want to return no events
@@ -59,10 +59,9 @@ def hog_function_filters_to_expr(filters: dict, team: Team, actions: dict[int, A
         all_filters_exprs.append(ast.And(exprs=exprs))
 
     if all_filters_exprs:
-        final_expr = ast.Or(exprs=all_filters_exprs)
-        return final_expr
-    else:
-        return ast.Constant(value=True)
+        return ast.Or(exprs=all_filters_exprs)
+
+    return ast.Constant(value=True)
 
 
 def filter_action_ids(filters: Optional[dict]) -> list[int]:
@@ -80,7 +79,9 @@ def compile_filters_expr(filters: Optional[dict], team: Team, actions: Optional[
     if actions is None:
         # If not provided as an optimization we fetch all actions
         actions_list = (
-            Action.objects.select_related("team").filter(team_id=team.id).filter(id__in=filter_action_ids(filters))
+            Action.objects.select_related("team")
+            .filter(team__project_id=team.project_id)
+            .filter(id__in=filter_action_ids(filters))
         )
         actions = {action.id: action for action in actions_list}
 
diff --git a/posthog/cdp/site_functions.py b/posthog/cdp/site_functions.py
index 6f4f7a3d5ffa5..f6ece18e28792 100644
--- a/posthog/cdp/site_functions.py
+++ b/posthog/cdp/site_functions.py
@@ -3,18 +3,12 @@
 from posthog.cdp.filters import hog_function_filters_to_expr
 from posthog.cdp.validation import transpile_template_code
 from posthog.hogql.compiler.javascript import JavaScriptCompiler
+from posthog.models.hog_functions.hog_function import HogFunction
 from posthog.models.plugin import transpile
-from posthog.models.team.team import Team
 
 
-def get_transpiled_function(id: str, source: str, filters: dict, inputs: dict, team: Team) -> str:
-    # Wrap in IIFE = Immediately Invoked Function Expression = to avoid polluting global scope
-    response = "(function() {\n\n"
-
-    # PostHog-JS adds itself to the window object for us to use
-    response += f"const posthog = window['__$$ph_site_app_{id}_posthog'] || window['__$$ph_site_app_{id}'] || window['posthog'];\n"
-    response += f"const missedInvocations = window['__$$ph_site_app_{id}_missed_invocations'] || (() => []);\n"
-    response += f"const callback = window['__$$ph_site_app_{id}_callback'] || (() => {'{}'});\n"
+def get_transpiled_function(hog_function: HogFunction) -> str:
+    response = ""
 
     # Build the inputs in three parts:
     # 1) a simple object with constants/scalars
@@ -27,7 +21,7 @@ def get_transpiled_function(id: str, source: str, filters: dict, inputs: dict, t
     compiler = JavaScriptCompiler()
 
     # TODO: reorder inputs to make dependencies work
-    for key, input in inputs.items():
+    for key, input in (hog_function.inputs or {}).items():
         value = input.get("value")
         key_string = json.dumps(str(key) or "<empty>")
         if (isinstance(value, str) and "{" in value) or isinstance(value, dict) or isinstance(value, list):
@@ -37,13 +31,6 @@ def get_transpiled_function(id: str, source: str, filters: dict, inputs: dict, t
         else:
             inputs_object.append(f"{key_string}: {json.dumps(value)}")
 
-    # Convert the filters to code
-    filters_expr = hog_function_filters_to_expr(filters, team, {})
-    filters_code = compiler.visit(filters_expr)
-
-    # Start with the STL functions
-    response += compiler.get_stl_code() + "\n"
-
     # A function to calculate the inputs from globals. If "initial" is true, no errors are logged.
     response += "function buildInputs(globals, initial) {\n"
 
@@ -60,43 +47,91 @@ def get_transpiled_function(id: str, source: str, filters: dict, inputs: dict, t
         response += "default: return null; }\n"
         response += "} catch (e) { if(!initial) {console.error('[POSTHOG-JS] Unable to compute value for inputs', key, e);} return null } }\n"
         response += "\n".join(inputs_append) + "\n"
+
     response += "return inputs;}\n"
 
-    # See plugin-transpiler/src/presets.ts
-    # transpile(source, 'site') == `(function () {let exports={};${code};return exports;})`
-    response += f"const response = {transpile(source, 'site')}();"
+    response += f"const source = {transpile(hog_function.hog, 'site')}();"
 
+    # Convert the global filters to code
+    filters_expr = hog_function_filters_to_expr(hog_function.filters or {}, hog_function.team, {})
+    filters_code = compiler.visit(filters_expr)
+
+    # Convert the mappings to code
+    mapping_code = ""
+    for mapping in hog_function.mappings or []:
+        mapping_inputs = mapping.get("inputs", {})
+        mapping_inputs_schema = mapping.get("inputs_schema", [])
+        mapping_filters_expr = hog_function_filters_to_expr(mapping.get("filters", {}) or {}, hog_function.team, {})
+        mapping_filters_code = compiler.visit(mapping_filters_expr)
+
+        mapping_code += f"if ({mapping_filters_code}) {{"
+        mapping_code += "(function (){"  # IIFE so that the code below has different globals than the filters above
+        mapping_code += "const newInputs = structuredClone(inputs); const __getGlobal = (key) => key === 'inputs' ? newInputs : globals[key];\n"
+
+        for schema in mapping_inputs_schema:
+            if "key" in schema and schema["key"] not in mapping_inputs:
+                mapping_inputs[schema["key"]] = {"value": schema.get("default", None)}
+
+        for key, input in mapping_inputs.items():
+            value = input.get("value") if input is not None else schema.get("default", None)
+            key_string = json.dumps(str(key) or "<empty>")
+            if (isinstance(value, str) and "{" in value) or isinstance(value, dict) or isinstance(value, list):
+                base_code = transpile_template_code(value, compiler)
+                mapping_code += (
+                    f"try {{ newInputs[{json.dumps(key)}] = {base_code}; }} catch (e) {{ console.error(e) }}\n"
+                )
+            else:
+                mapping_code += f"newInputs[{json.dumps(key)}] = {json.dumps(value)};\n"
+        mapping_code += "source.onEvent({ inputs: newInputs, posthog });"
+        mapping_code += "})();"
+        mapping_code += "}\n"
+
+    # We are exposing an init function which is what the client will use to actually run this setup code.
+    # The return includes any extra methods that the client might need to use - so far just processEvent
     response += (
         """
-    function processEvent(globals) {
-        if (!('onEvent' in response)) { return; };
-        const inputs = buildInputs(globals);
-        const filterGlobals = { ...globals.groups, ...globals.event, person: globals.person, inputs, pdi: { distinct_id: globals.event.distinct_id, person: globals.person } };
-        let __getGlobal = (key) => filterGlobals[key];
-        const filterMatches = """
+    let processEvent = undefined;
+    if ('onEvent' in source) {
+        processEvent = function processEvent(globals, posthog) {
+            if (!('onEvent' in source)) { return; };
+            const inputs = buildInputs(globals);
+            const filterGlobals = { ...globals.groups, ...globals.event, person: globals.person, inputs, pdi: { distinct_id: globals.event.distinct_id, person: globals.person } };
+            let __getGlobal = (key) => filterGlobals[key];
+            const filterMatches = """
         + filters_code
         + """;
-        if (filterMatches) { response.onEvent({ ...globals, inputs, posthog }); }
+            if (!filterMatches) { return; }
+            """
+        + (mapping_code or ";")
+        + """
+        }
     }
-    if ('onLoad' in response) {
-        const r = response.onLoad({ inputs: buildInputs({}, true), posthog: posthog });
-        const done = (success = true) => {
-            if (success) {
-                missedInvocations().forEach(processEvent);
-                posthog.on('eventCaptured', (event) => { processEvent(posthog.siteApps.globalsForEvent(event)) });
-            } else {
-                console.error('[POSTHOG-JS] Site function failed to load', response)
+
+    function init(config) {
+        const posthog = config.posthog;
+        const callback = config.callback;
+        if ('onLoad' in source) {
+            const globals = {
+                person: {
+                    properties: posthog.get_property('$stored_person_properties'),
+                }
             }
-            callback(success);
-        };
-        if (r && typeof r.then === 'function' && typeof r.finally === 'function') { r.catch(() => done(false)).then(() => done(true)) } else { done(true) }
-    } else if ('onEvent' in response) {
-        missedInvocations().forEach(processEvent);
-        posthog.on('eventCaptured', (event) => { processEvent(posthog.siteApps.globalsForEvent(event)) })
+            const r = source.onLoad({ inputs: buildInputs(globals, true), posthog: posthog });
+            if (r && typeof r.then === 'function' && typeof r.finally === 'function') { r.catch(() => callback(false)).then(() => callback(true)) } else { callback(true) }
+        } else {
+            callback(true);
+        }
+
+        return {
+            processEvent: (globals) => processEvent(globals, posthog)
+        }
     }
-    """
+
+    return { init: init };"""
     )
 
-    response += "\n})();"
+    # Wrap in IIFE = Immediately Invoked (invokable) Function Expression = to avoid polluting global scope
+    # Add collected STL functions above the generated code
+    response = "(function() {\n" + compiler.get_stl_code() + "\n" + response + "\n})"
 
     return response
diff --git a/posthog/cdp/templates/__init__.py b/posthog/cdp/templates/__init__.py
index 3434fab954d16..57855bb7ca96f 100644
--- a/posthog/cdp/templates/__init__.py
+++ b/posthog/cdp/templates/__init__.py
@@ -44,8 +44,10 @@
 from ._siteapps.template_hogdesk import template as hogdesk
 from ._siteapps.template_notification_bar import template as notification_bar
 from ._siteapps.template_pineapple_mode import template as pineapple_mode
+from ._siteapps.template_debug_posthog import template as debug_posthog
 from ._internal.template_broadcast import template_new_broadcast as _broadcast
 from ._internal.template_blank import blank_site_destination, blank_site_app
+from ._transformations.template_pass_through import template as pass_through_transformation
 
 HOG_FUNCTION_TEMPLATES = [
     _broadcast,
@@ -96,6 +98,8 @@
     hogdesk,
     notification_bar,
     pineapple_mode,
+    pass_through_transformation,
+    debug_posthog,
 ]
 
 
diff --git a/posthog/cdp/templates/_internal/template_blank.py b/posthog/cdp/templates/_internal/template_blank.py
index 4f141ad9fc3e8..6b55ca796903f 100644
--- a/posthog/cdp/templates/_internal/template_blank.py
+++ b/posthog/cdp/templates/_internal/template_blank.py
@@ -1,11 +1,11 @@
-from posthog.cdp.templates.hog_function_template import HogFunctionTemplate
+from posthog.cdp.templates.hog_function_template import HogFunctionMappingTemplate, HogFunctionTemplate
 
 blank_site_destination: HogFunctionTemplate = HogFunctionTemplate(
     status="client-side",
     type="site_destination",
     id="template-blank-site-destination",
     name="New client-side destination",
-    description="Run code on your website when an event is sent to PostHog. Works only with posthog-js when opt_in_site_apps is set to true.",
+    description="New destination with complex event mapping. Works only with posthog-js when opt_in_site_apps is set to true.",
     icon_url="/static/hedgehog/builder-hog-01.png",
     category=["Custom", "Analytics"],
     hog="""
@@ -15,9 +15,9 @@
     await new Promise((resolve) => window.setTimeout(resolve, 1000))
     console.log("🦔 Script loaded")
 }
-export function onEvent({ posthog, ...globals }) {
-    const { event, person } = globals
-    console.log(`🦔 Sending event: ${event.event}`, globals)
+export function onEvent({ inputs, posthog }) {
+    console.log(`🦔 Sending event of type ${inputs.eventType}`, inputs.payload)
+    // fetch('url', { method: 'POST', body: JSON.stringify(inputs.payload) })
 }
 """.strip(),
     inputs_schema=[
@@ -50,6 +50,88 @@
             "required": True,
         },
     ],
+    mappings=[],
+    mapping_templates=[
+        HogFunctionMappingTemplate(
+            name="Aquisition",
+            include_by_default=True,
+            filters={"events": [{"id": "$pageview", "type": "events"}]},
+            inputs_schema=[
+                {
+                    "key": "eventType",
+                    "type": "string",
+                    "label": "Event Type",
+                    "description": "The destination's event type",
+                    "default": "acquisition",
+                    "required": True,
+                },
+                {
+                    "key": "payload",
+                    "type": "json",
+                    "label": "Payload",
+                    "description": "Payload sent to the destination.",
+                    "default": {
+                        "event": "{event}",
+                        "person": "{person}",
+                    },
+                    "secret": False,
+                    "required": True,
+                },
+            ],
+        ),
+        HogFunctionMappingTemplate(
+            name="Conversion",
+            filters={"events": [{"id": "$autocapture", "type": "events"}]},
+            inputs_schema=[
+                {
+                    "key": "eventType",
+                    "type": "string",
+                    "label": "Event Type",
+                    "description": "The destination's event type",
+                    "default": "conversion",
+                    "required": True,
+                },
+                {
+                    "key": "payload",
+                    "type": "json",
+                    "label": "Payload",
+                    "description": "Payload sent to the destination.",
+                    "default": {
+                        "event": "{event}",
+                        "person": "{person}",
+                    },
+                    "secret": False,
+                    "required": True,
+                },
+            ],
+        ),
+        HogFunctionMappingTemplate(
+            name="Retention",
+            filters={"events": [{"id": "$pageleave", "type": "events"}]},
+            inputs_schema=[
+                {
+                    "key": "eventType",
+                    "type": "string",
+                    "label": "Event Type",
+                    "description": "The destination's event type",
+                    "default": "retention",
+                    "required": True,
+                },
+                {
+                    "key": "payload",
+                    "type": "json",
+                    "label": "Payload",
+                    "description": "Payload sent to the destination.",
+                    "default": {
+                        "event": "{event}",
+                        "person": "{person}",
+                    },
+                    "secret": False,
+                    "required": True,
+                },
+            ],
+        ),
+    ],
 )
 
 blank_site_app: HogFunctionTemplate = HogFunctionTemplate(
diff --git a/posthog/cdp/templates/_siteapps/template_debug_posthog.py b/posthog/cdp/templates/_siteapps/template_debug_posthog.py
new file mode 100644
index 0000000000000..cf964a944bbb6
--- /dev/null
+++ b/posthog/cdp/templates/_siteapps/template_debug_posthog.py
@@ -0,0 +1,45 @@
+from posthog.cdp.templates.hog_function_template import HogFunctionTemplate
+
+template: HogFunctionTemplate = HogFunctionTemplate(
+    status="client-side",
+    type="site_app",
+    id="template-debug-posthog-js",
+    name="PostHog JS debugger",
+    description="Enable extra debugging tools on your posthog-js",
+    icon_url="/static/hedgehog/builder-hog-01.png",
+    category=["Custom"],
+    hog="""
+export function onLoad({ inputs, posthog }) {
+    console.log("Enabling PostHog.js debugging", posthog)
+
+    if (inputs.enable_debugging) {
+        posthog.debug(true)
+    }
+
+    if (inputs.capture_config) {
+        posthog.capture("posthog-js debug", {
+            config: posthog.config
+        })
+    }
+}
+""".strip(),
+    inputs_schema=[
+        {
+            "key": "capture_config",
+            "type": "boolean",
+            "label": "Capture debug event on load",
+            "secret": False,
+            "default": False,
+            "required": False,
+            "description": "Whether to capture an event on load including the posthog config",
+        },
+        {
+            "key": "enable_debugging",
+            "type": "boolean",
+            "label": "Enable debugging",
+            "secret": False,
+            "default": False,
+            "required": False,
+        },
+    ],
+)
diff --git a/posthog/cdp/templates/_transformations/template_pass_through.py b/posthog/cdp/templates/_transformations/template_pass_through.py
new file mode 100644
index 0000000000000..5a4e88e003d31
--- /dev/null
+++ b/posthog/cdp/templates/_transformations/template_pass_through.py
@@ -0,0 +1,18 @@
+from posthog.cdp.templates.hog_function_template import HogFunctionTemplate
+
+template: HogFunctionTemplate = HogFunctionTemplate(
+    status="alpha",
+    type="transformation",
+    id="template-blank-transformation",
+    name="Custom transformation",
+    description="This is a starter template for custom transformations",
+    icon_url="/static/hedgehog/builder-hog-01.png",
+    category=["Custom"],
+    hog="""
+// This is a blank template for custom transformations
+// The function receives `event` as a global object and expects it to be returned
+// If you return null then the event will be discarded
+return event
+""".strip(),
+    inputs_schema=[],
+)
diff --git a/posthog/cdp/templates/google_ads/template_google_ads.py b/posthog/cdp/templates/google_ads/template_google_ads.py
index 3743ca93db541..9cc61d507fe56 100644
--- a/posthog/cdp/templates/google_ads/template_google_ads.py
+++ b/posthog/cdp/templates/google_ads/template_google_ads.py
@@ -55,6 +55,7 @@
             "type": "integration",
             "integration": "google-ads",
             "label": "Google Ads account",
+            "requiredScopes": "https://www.googleapis.com/auth/adwords https://www.googleapis.com/auth/userinfo.email",
             "secret": False,
             "required": True,
         },
diff --git a/posthog/cdp/templates/helpers.py b/posthog/cdp/templates/helpers.py
index e26f55f842a73..6f1eba04ae75d 100644
--- a/posthog/cdp/templates/helpers.py
+++ b/posthog/cdp/templates/helpers.py
@@ -16,7 +16,7 @@ class BaseHogFunctionTemplateTest(BaseTest):
 
     def setUp(self):
         super().setUp()
-        self.compiled_hog = compile_hog(self.template.hog, supported_functions={"fetch", "postHogCapture"})
+        self.compiled_hog = compile_hog(self.template.hog, self.template.type)
 
         self.mock_print = MagicMock(side_effect=lambda *args: print("[DEBUG HogFunctionPrint]", *args))  # noqa: T201
         # Side effect - log the fetch call and return  with sensible output
diff --git a/posthog/cdp/templates/hog_function_template.py b/posthog/cdp/templates/hog_function_template.py
index c3227f9b8eb73..0ebfc1f1c37dc 100644
--- a/posthog/cdp/templates/hog_function_template.py
+++ b/posthog/cdp/templates/hog_function_template.py
@@ -23,6 +23,22 @@ class HogFunctionSubTemplate:
     inputs: Optional[dict] = None
 
 
+@dataclasses.dataclass(frozen=True)
+class HogFunctionMapping:
+    filters: Optional[dict] = None
+    inputs: Optional[dict] = None
+    inputs_schema: Optional[list[dict]] = None
+
+
+@dataclasses.dataclass(frozen=True)
+class HogFunctionMappingTemplate:
+    name: str
+    include_by_default: Optional[bool] = None
+    filters: Optional[dict] = None
+    inputs: Optional[dict] = None
+    inputs_schema: Optional[list[dict]] = None
+
+
 @dataclasses.dataclass(frozen=True)
 class HogFunctionTemplate:
     status: Literal["alpha", "beta", "stable", "free", "client-side"]
@@ -30,6 +46,7 @@ class HogFunctionTemplate:
         "destination",
         "site_destination",
         "site_app",
+        "transformation",
         "shared",
         "email",
         "sms",
@@ -46,6 +63,8 @@ class HogFunctionTemplate:
     category: list[str]
     sub_templates: Optional[list[HogFunctionSubTemplate]] = None
     filters: Optional[dict] = None
+    mappings: Optional[list[HogFunctionMapping]] = None
+    mapping_templates: Optional[list[HogFunctionMappingTemplate]] = None
     masking: Optional[dict] = None
     icon_url: Optional[str] = None
 
diff --git a/posthog/cdp/templates/hubspot/template_hubspot.py b/posthog/cdp/templates/hubspot/template_hubspot.py
index f8f6c9cf06a72..a36c850725972 100644
--- a/posthog/cdp/templates/hubspot/template_hubspot.py
+++ b/posthog/cdp/templates/hubspot/template_hubspot.py
@@ -61,6 +61,7 @@
             "type": "integration",
             "integration": "hubspot",
             "label": "Hubspot connection",
+            "requiredScopes": "crm.objects.contacts.write crm.objects.contacts.read",
             "secret": False,
             "required": True,
         },
@@ -307,6 +308,7 @@
             "type": "integration",
             "integration": "hubspot",
             "label": "Hubspot connection",
+            "requiredScopes": "analytics.behavioral_events.send behavioral_events.event_definitions.read_write",
             "secret": False,
             "required": True,
         },
diff --git a/posthog/cdp/templates/salesforce/template_salesforce.py b/posthog/cdp/templates/salesforce/template_salesforce.py
index eedfd9980efb1..844c86ad15803 100644
--- a/posthog/cdp/templates/salesforce/template_salesforce.py
+++ b/posthog/cdp/templates/salesforce/template_salesforce.py
@@ -15,6 +15,7 @@
         "type": "integration",
         "integration": "salesforce",
         "label": "Salesforce account",
+        "requiredScopes": "refresh_token full",
         "secret": False,
         "required": True,
     }
diff --git a/posthog/cdp/templates/slack/template_slack.py b/posthog/cdp/templates/slack/template_slack.py
index 16bb0383c1c0b..8cfb5a84101de 100644
--- a/posthog/cdp/templates/slack/template_slack.py
+++ b/posthog/cdp/templates/slack/template_slack.py
@@ -34,6 +34,7 @@
             "type": "integration",
             "integration": "slack",
             "label": "Slack workspace",
+            "requiredScopes": "channels:read groups:read chat:write chat:write.customize",
             "secret": False,
             "required": True,
         },
diff --git a/posthog/cdp/templates/test_cdp_templates.py b/posthog/cdp/templates/test_cdp_templates.py
index 4c873a9a820ec..d4a5520a2fd18 100644
--- a/posthog/cdp/templates/test_cdp_templates.py
+++ b/posthog/cdp/templates/test_cdp_templates.py
@@ -10,8 +10,9 @@ def setUp(self):
 
     def test_templates_are_valid(self):
         for template in HOG_FUNCTION_TEMPLATES:
-            assert validate_inputs_schema(template.inputs_schema)
+            if template.inputs_schema:
+                assert validate_inputs_schema(template.inputs_schema)
 
             if template.type not in TYPES_WITH_TRANSPILED_FILTERS:
-                bytecode = compile_hog(template.hog)
+                bytecode = compile_hog(template.hog, template.type)
                 assert bytecode[0] == "_H"
diff --git a/posthog/cdp/templates/webhook/template_webhook.py b/posthog/cdp/templates/webhook/template_webhook.py
index f27822c5e0c24..49e350736de51 100644
--- a/posthog/cdp/templates/webhook/template_webhook.py
+++ b/posthog/cdp/templates/webhook/template_webhook.py
@@ -78,6 +78,7 @@
             "label": "Headers",
             "secret": False,
             "required": False,
+            "default": {"Content-Type": "application/json"},
         },
         {
             "key": "debug",
diff --git a/posthog/cdp/test/test_site_functions.py b/posthog/cdp/test/test_site_functions.py
index 9852201353cdc..0b6c0bc1bb8a6 100644
--- a/posthog/cdp/test/test_site_functions.py
+++ b/posthog/cdp/test/test_site_functions.py
@@ -1,6 +1,12 @@
+import json
+import subprocess
+import tempfile
+from inline_snapshot import snapshot
+import pytest
 from django.test import TestCase
 from posthog.cdp.site_functions import get_transpiled_function
 from posthog.models.action.action import Action
+from posthog.models.hog_functions.hog_function import HogFunction
 from posthog.models.organization import Organization
 from posthog.models.project import Project
 from posthog.models.plugin import TranspilerError
@@ -19,93 +25,139 @@ def setUp(self):
             name="Test project",
         )
 
+        self.hog_function = HogFunction(
+            id="123",
+            team=self.team,
+            name="Test Hog Function",
+            hog='export function onLoad() { console.log("Hello, World!"); }',
+            filters={},
+            inputs={},
+        )
+
+    def compile_and_run(self):
+        result = get_transpiled_function(self.hog_function)
+        with tempfile.NamedTemporaryFile(delete=False) as f:
+            f.write(result.encode("utf-8"))
+            f.flush()
+            # NOTE: Nodejs isn't the right environment as it is really for the browser but we are only checking the output is valid, not that it actually runs
+            # More of a sanity check that our templating isn't broken
+            output = subprocess.check_output(["node", f.name])
+            assert output == b""
+
+        return result
+
     def test_get_transpiled_function_basic(self):
-        id = "123"
-        source = 'export function onLoad() { console.log("Hello, World!"); }'
-        filters: dict = {}
-        inputs: dict = {}
-        team = self.team
+        result = self.compile_and_run()
+        assert isinstance(result, str)
+        assert 'console.log("Hello, World!")' in result
+
+        # NOTE: We do one inlne snapshot here so we can have an easy glance at what it generally looks like - all other tests we should just check specific parts
+        assert result == snapshot(
+            """\
+(function() {
+
+function buildInputs(globals, initial) {
+let inputs = {
+};
+let __getGlobal = (key) => key === 'inputs' ? inputs : globals[key];
+return inputs;}
+const source = (function () {let exports={};"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onLoad = onLoad;
+function onLoad() {
+  console.log("Hello, World!");
+};return exports;})();
+    let processEvent = undefined;
+    if ('onEvent' in source) {
+        processEvent = function processEvent(globals, posthog) {
+            if (!('onEvent' in source)) { return; };
+            const inputs = buildInputs(globals);
+            const filterGlobals = { ...globals.groups, ...globals.event, person: globals.person, inputs, pdi: { distinct_id: globals.event.distinct_id, person: globals.person } };
+            let __getGlobal = (key) => filterGlobals[key];
+            const filterMatches = true;
+            if (!filterMatches) { return; }
+            ;
+        }
+    }
+
+    function init(config) {
+        const posthog = config.posthog;
+        const callback = config.callback;
+        if ('onLoad' in source) {
+            const globals = {
+                person: {
+                    properties: posthog.get_property('$stored_person_properties'),
+                }
+            }
+            const r = source.onLoad({ inputs: buildInputs(globals, true), posthog: posthog });
+            if (r && typeof r.then === 'function' && typeof r.finally === 'function') { r.catch(() => callback(false)).then(() => callback(true)) } else { callback(true) }
+        } else {
+            callback(true);
+        }
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        return {
+            processEvent: (globals) => processEvent(globals, posthog)
+        }
+    }
 
-        self.assertIsInstance(result, str)
-        self.assertIn('console.log("Hello, World!")', result)
-        self.assertIn(f"window['__$$ph_site_app_{id}_posthog']", result)
+    return { init: init };
+})\
+"""
+        )
 
     def test_get_transpiled_function_with_static_input(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.message); }"
-        filters: dict = {}
-        inputs = {"message": {"value": "Hello, Inputs!"}}
-        team = self.team
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.message); }"
+        self.hog_function.inputs = {"message": {"value": "Hello, Inputs!"}}
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.message);", result)
-        self.assertIn("inputs = {", result)
-        self.assertIn('"message": "Hello, Inputs!"', result)
+        assert "console.log(inputs.message);" in result
+        assert "inputs = {" in result
+        assert '"message": "Hello, Inputs!"' in result
 
     def test_get_transpiled_function_with_template_input(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.greeting); }"
-        filters: dict = {}
-        inputs = {"greeting": {"value": "Hello, {person.properties.name}!"}}
-        team = self.team
-
-        result = get_transpiled_function(id, source, filters, inputs, team)
-
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.greeting);", result)
-        # Check that the input processing code is included
-        self.assertIn("function getInputsKey", result)
-        self.assertIn('inputs["greeting"] = getInputsKey("greeting");', result)
-        self.assertIn('case "greeting": return ', result)
-        self.assertIn('__getGlobal("person")', result)
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.greeting); }"
+        self.hog_function.inputs = {"greeting": {"value": "Hello, {person.properties.name}!"}}
+        result = self.compile_and_run()
+
+        assert "console.log(inputs.greeting);" in result
+        assert "function getInputsKey" in result
+        assert 'inputs["greeting"] = getInputsKey("greeting");' in result
+        assert 'case "greeting": return ' in result
+        assert '__getGlobal("person")' in result
 
     def test_get_transpiled_function_with_filters(self):
-        id = "123"
-        source = "export function onEvent(event) { console.log(event.event); }"
-        filters: dict = {"events": [{"id": "$pageview", "name": "$pageview", "type": "events", "order": 0}]}
-        inputs: dict = {}
-        team = self.team
+        self.hog_function.hog = "export function onEvent(globals) { console.log(globals); }"
+        self.hog_function.filters = {"events": [{"id": "$pageview", "name": "$pageview", "type": "events", "order": 0}]}
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(event.event);", result)
-        self.assertIn("const filterMatches = ", result)
-        self.assertIn('__getGlobal("event") == "$pageview"', result)
-        self.assertIn("if (filterMatches) { response.onEvent({", result)
+        assert "console.log(globals);" in result
+        assert "const filterMatches = " in result
+        assert '__getGlobal("event") == "$pageview"' in result
+        assert "const filterMatches = !!(!!((__getGlobal" in result
+        assert "if (!filterMatches) { return; }" in result
 
     def test_get_transpiled_function_with_invalid_template_input(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.greeting); }"
-        filters: dict = {}
-        inputs = {"greeting": {"value": "Hello, {person.properties.nonexistent_property}!"}}
-        team = self.team
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.greeting); }"
+        self.hog_function.inputs = {"greeting": {"value": "Hello, {person.properties.nonexistent_property}!"}}
 
-        # This should not raise an exception during transpilation
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.greeting);", result)
+        assert "console.log(inputs.greeting);" in result
 
     def test_get_transpiled_function_with_syntax_error_in_source(self):
-        id = "123"
-        source = 'export function onLoad() { console.log("Missing closing brace");'
-        filters: dict = {}
-        inputs: dict = {}
-        team = self.team
+        self.hog_function.hog = 'export function onLoad() { console.log("Missing closing brace");'
 
-        with self.assertRaises(TranspilerError):
-            get_transpiled_function(id, source, filters, inputs, team)
+        with pytest.raises(TranspilerError):
+            get_transpiled_function(self.hog_function)
 
     def test_get_transpiled_function_with_complex_inputs(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.complexInput); }"
-        filters: dict = {}
-        inputs = {
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.complexInput); }"
+        self.hog_function.inputs = {
             "complexInput": {
                 "value": {
                     "nested": "{event.properties.url}",
@@ -113,129 +165,182 @@ def test_get_transpiled_function_with_complex_inputs(self):
                 }
             }
         }
-        team = self.team
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.complexInput);", result)
-        self.assertIn("function getInputsKey", result)
-        self.assertIn('inputs["complexInput"] = getInputsKey("complexInput");', result)
+        assert "console.log(inputs.complexInput);" in result
+        assert "function getInputsKey" in result
+        assert 'inputs["complexInput"] = getInputsKey("complexInput");' in result
 
     def test_get_transpiled_function_with_empty_inputs(self):
-        id = "123"
-        source = 'export function onLoad() { console.log("No inputs"); }'
-        filters: dict = {}
-        inputs: dict = {}
-        team = self.team
+        self.hog_function.hog = 'export function onLoad() { console.log("No inputs"); }'
+        self.hog_function.inputs = {}
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn('console.log("No inputs");', result)
-        self.assertIn("let inputs = {\n};", result)
+        assert 'console.log("No inputs");' in result
+        assert "let inputs = {\n};" in result
 
     def test_get_transpiled_function_with_non_template_string(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.staticMessage); }"
-        filters: dict = {}
-        inputs = {"staticMessage": {"value": "This is a static message."}}
-        team = self.team
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.staticMessage); }"
+        self.hog_function.inputs = {"staticMessage": {"value": "This is a static message."}}
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.staticMessage);", result)
-        # Since the value does not contain '{', it should be added directly to inputs object
-        self.assertIn('"staticMessage": "This is a static message."', result)
-        self.assertNotIn("function getInputsKey", result)
+        assert "console.log(inputs.staticMessage);" in result
+        assert '"staticMessage": "This is a static message."' in result
+        assert "function getInputsKey" not in result
 
     def test_get_transpiled_function_with_list_inputs(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.messages); }"
-        filters: dict = {}
-        inputs = {"messages": {"value": ["Hello", "World", "{person.properties.name}"]}}
-        team = self.team
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.messages); }"
+        self.hog_function.inputs = {"messages": {"value": ["Hello", "World", "{person.properties.name}"]}}
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.messages);", result)
-        self.assertIn("function getInputsKey", result)
-        self.assertIn('inputs["messages"] = getInputsKey("messages");', result)
+        assert "console.log(inputs.messages);" in result
+        assert "function getInputsKey" in result
+        assert 'inputs["messages"] = getInputsKey("messages");' in result
 
     def test_get_transpiled_function_with_event_filter(self):
-        id = "123"
-        source = "export function onEvent(event) { console.log(event.properties.url); }"
-        filters: dict = {
+        self.hog_function.hog = "export function onEvent(event) { console.log(event.properties.url); }"
+        self.hog_function.filters = {
             "events": [{"id": "$pageview", "name": "$pageview", "type": "events"}],
             "filter_test_accounts": True,
         }
-        inputs: dict = {}
-        team = self.team
-        # Assume that team.test_account_filters is set up
-        team.test_account_filters = [{"key": "email", "value": "@test.com", "operator": "icontains", "type": "person"}]
-        team.save()
-
-        result = get_transpiled_function(id, source, filters, inputs, team)
-
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(event.properties.url);", result)
-        self.assertIn("const filterMatches = ", result)
-        self.assertIn('__getGlobal("event") == "$pageview"', result)
-        self.assertIn(
-            '(ilike(__getProperty(__getProperty(__getGlobal("person"), "properties", true), "email", true), "%@test.com%")',
-            result,
+
+        self.team.test_account_filters = [
+            {"key": "email", "value": "@test.com", "operator": "icontains", "type": "person"}
+        ]
+        self.team.save()
+
+        result = self.compile_and_run()
+
+        assert "console.log(event.properties.url);" in result
+        assert "const filterMatches = " in result
+        assert '__getGlobal("event") == "$pageview"' in result
+        assert (
+            '(ilike(__getProperty(__getProperty(__getGlobal("person"), "properties", true), "email", true), "%@test.com%")'
+            in result
         )
 
     def test_get_transpiled_function_with_groups(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.groupInfo); }"
-        filters: dict = {}
-        inputs = {"groupInfo": {"value": "{groups['company']}"}}
-        team = self.team
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.groupInfo); }"
+        self.hog_function.inputs = {"groupInfo": {"value": "{groups['company']}"}}
 
-        # Set up group type mapping
-        GroupTypeMapping.objects.create(team=team, group_type="company", group_type_index=0, project=self.project)
+        GroupTypeMapping.objects.create(team=self.team, group_type="company", group_type_index=0, project=self.project)
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.groupInfo);", result)
-        self.assertIn('inputs["groupInfo"] = getInputsKey("groupInfo");', result)
-        self.assertIn('__getProperty(__getGlobal("groups"), "company", false)', result)
+        assert "console.log(inputs.groupInfo);" in result
+        assert 'inputs["groupInfo"] = getInputsKey("groupInfo");' in result
+        assert '__getProperty(__getGlobal("groups"), "company", false)' in result
 
     def test_get_transpiled_function_with_missing_group(self):
-        id = "123"
-        source = "export function onLoad() { console.log(inputs.groupInfo); }"
-        filters: dict = {}
-        inputs = {"groupInfo": {"value": "{groups['nonexistent']}"}}
-        team = self.team
+        self.hog_function.hog = "export function onLoad() { console.log(inputs.groupInfo); }"
+        self.hog_function.inputs = {"groupInfo": {"value": "{groups['nonexistent']}"}}
 
-        result = get_transpiled_function(id, source, filters, inputs, team)
+        result = self.compile_and_run()
 
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(inputs.groupInfo);", result)
-        self.assertIn('inputs["groupInfo"] = getInputsKey("groupInfo");', result)
-        self.assertIn('__getProperty(__getGlobal("groups"), "nonexistent"', result)
+        assert "console.log(inputs.groupInfo);" in result
+        assert 'inputs["groupInfo"] = getInputsKey("groupInfo");' in result
+        assert '__getProperty(__getGlobal("groups"), "nonexistent"' in result
 
     def test_get_transpiled_function_with_complex_filters(self):
         action = Action.objects.create(team=self.team, name="Test Action")
         action.steps = [{"event": "$pageview", "url": "https://example.com"}]  # type: ignore
         action.save()
-        id = "123"
-        source = "export function onEvent(event) { console.log(event.event); }"
-        filters: dict = {
+
+        self.hog_function.hog = "export function onEvent(globals) { console.log(globals); }"
+        self.hog_function.filters = {
             "events": [{"id": "$pageview", "name": "$pageview", "type": "events"}],
             "actions": [{"id": str(action.pk), "name": "Test Action", "type": "actions"}],
             "filter_test_accounts": True,
         }
-        inputs: dict = {}
-        team = self.team
-        result = get_transpiled_function(id, source, filters, inputs, team)
-
-        self.assertIsInstance(result, str)
-        self.assertIn("console.log(event.event);", result)
-        self.assertIn("const filterMatches = ", result)
-        self.assertIn('__getGlobal("event") == "$pageview"', result)
-        self.assertIn("https://example.com", result)
+
+        result = self.compile_and_run()
+
+        assert "console.log(globals);" in result
+        assert "const filterMatches = " in result
+        assert '__getGlobal("event") == "$pageview"' in result
+        assert "https://example.com" in result
+
+    def test_get_transpiled_function_with_mappings(self):
+        self.hog_function.hog = "export function onLoad({ inputs, posthog }) { console.log(inputs); }"
+        self.hog_function.inputs = {"greeting": {"value": "Hello, {person.properties.nonexistent_property}!"}}
+        self.hog_function.filters = {
+            "events": [{"id": "$pageview", "name": "$pageview", "type": "events"}],
+        }
+        self.hog_function.mappings = [
+            {
+                "inputs": {"greeting": {"value": "Hallo, {person.properties.nonexistent_property}!"}},
+                "filters": {"events": [{"id": "$autocapture", "name": "$autocapture", "type": "events"}]},
+            }
+        ]
+
+        result = self.compile_and_run()
+
+        assert "console.log(inputs);" in result
+        assert 'const filterMatches = !!(!!((__getGlobal("event") == "$pageview")));' in result
+        assert 'if (!!(!!((__getGlobal("event") == "$autocapture")))) {' in result
+        assert "const newInputs = structuredClone(inputs);" in result
+        assert 'newInputs["greeting"] = concat("Hallo, ", __getProperty' in result
+
+    def test_run_function_onload(self):
+        self.hog_function.hog = "export function onLoad({ inputs, posthog }) { console.log(inputs.message); }"
+        self.hog_function.filters = {"events": [{"id": "$pageview", "name": "$pageview", "type": "events", "order": 0}]}
+        self.hog_function.inputs = {"message": {"value": "Hello World {person.properties.name}"}}
+
+        result = self.compile_and_run()
+        assert "Hello World" in result
+
+        response = self._execute_javascript(
+            result
+            + "().init({ posthog: { get_property: () => ({name: 'Bob'}) }, callback: () => { console.log('Loaded') } })"
+        )
+        assert "Hello World Bob\nLoaded" == response.strip()
+
+    def test_run_function_onevent(self):
+        self.hog_function.hog = "export function onEvent({ inputs }) { console.log(inputs.message); }"
+        # self.hog_function.filters = {"events": [{"id": "$pageview", "name": "$pageview", "type": "events", "order": 0}]}
+        self.hog_function.inputs = {"message": {"value": "Hello World {event.properties.id}"}}
+        self.hog_function.mappings = [
+            {
+                "inputs": {"greeting": {"value": "Hallo, {person.properties.nonexistent_property}!"}},
+                "filters": {"events": [{"id": "$pageview", "name": "$pageview", "type": "events"}]},
+            }
+        ]
+
+        result = self.compile_and_run()
+        assert "Hello World" in result
+
+        globals = {
+            "event": {"event": "$pageview", "properties": {"id": "banana"}},
+            "groups": {},
+            "person": {"properties": {"name": "Bob"}},
+        }
+        response = self._execute_javascript(
+            result
+            + "().init({ posthog: { get_property: () => ({name: 'Bob'}) }, callback: () => { console.log('Loaded') } }).processEvent("
+            + json.dumps(globals)
+            + ")"
+        )
+        assert "Loaded\nHello World banana" == response.strip()
+
+        globals = {
+            "event": {"event": "$autocapture", "properties": {"id": "banana"}},
+            "groups": {},
+            "person": {"properties": {"name": "Bob"}},
+        }
+        response = self._execute_javascript(
+            result
+            + "().init({ posthog: { get_property: () => ({name: 'Bob'}) }, callback: () => { console.log('Loaded') } }).processEvent("
+            + json.dumps(globals)
+            + ")"
+        )
+        assert "Loaded" == response.strip()
+
+    def _execute_javascript(self, js) -> str:
+        with tempfile.NamedTemporaryFile(delete=False) as f:
+            f.write(js.encode("utf-8"))
+            f.flush()
+            return subprocess.check_output(["node", f.name]).decode("utf-8")
diff --git a/posthog/cdp/validation.py b/posthog/cdp/validation.py
index 9c71c894e93db..ac7f19405cfd5 100644
--- a/posthog/cdp/validation.py
+++ b/posthog/cdp/validation.py
@@ -56,7 +56,7 @@ class InputsSchemaItemSerializer(serializers.Serializer):
         choices=["string", "boolean", "dictionary", "choice", "json", "integration", "integration_field", "email"]
     )
     key = serializers.CharField()
-    label = serializers.CharField(required=False)  # type: ignore
+    label = serializers.CharField(required=False, allow_blank=True)  # type: ignore
     choices = serializers.ListField(child=serializers.DictField(), required=False)
     required = serializers.BooleanField(default=False)  # type: ignore
     default = serializers.JSONField(required=False)
@@ -65,6 +65,7 @@ class InputsSchemaItemSerializer(serializers.Serializer):
     integration = serializers.CharField(required=False)
     integration_key = serializers.CharField(required=False)
     integration_field = serializers.ChoiceField(choices=["slack_channel"], required=False)
+    requiredScopes = serializers.CharField(required=False)
 
     # TODO Validate choices if type=choice
 
@@ -184,13 +185,16 @@ def validate_inputs(
     return validated_inputs
 
 
-def compile_hog(hog: str, supported_functions: Optional[set[str]] = None, in_repl: Optional[bool] = False) -> list[Any]:
+def compile_hog(hog: str, hog_type: str, in_repl: Optional[bool] = False) -> list[Any]:
     # Attempt to compile the hog
     try:
         program = parse_program(hog)
-        return create_bytecode(
-            program, supported_functions=supported_functions or {"fetch", "postHogCapture"}, in_repl=in_repl
-        ).bytecode
+        supported_functions = set()
+
+        if hog_type == "destination":
+            supported_functions = {"fetch", "postHogCapture"}
+
+        return create_bytecode(program, supported_functions=supported_functions, in_repl=in_repl).bytecode
     except Exception as e:
         logger.error(f"Failed to compile hog {e}", exc_info=True)
         raise serializers.ValidationError({"hog": "Hog code has errors."})
diff --git a/posthog/clickhouse/cluster.py b/posthog/clickhouse/cluster.py
index 3aa67c94ff3b5..75c91db9da75f 100644
--- a/posthog/clickhouse/cluster.py
+++ b/posthog/clickhouse/cluster.py
@@ -52,7 +52,9 @@ def result(
 
 class ConnectionInfo(NamedTuple):
     address: str
-    port: int
+
+    def make_pool(self) -> ChPool:
+        return make_ch_pool(host=self.address)
 
 
 class HostInfo(NamedTuple):
@@ -67,10 +69,10 @@ class HostInfo(NamedTuple):
 class ClickhouseCluster:
     def __init__(self, bootstrap_client: Client, extra_hosts: Sequence[ConnectionInfo] | None = None) -> None:
         self.__hosts = [
-            HostInfo(ConnectionInfo(host_address, port), shard_num, replica_num)
-            for (host_address, port, shard_num, replica_num) in bootstrap_client.execute(
+            HostInfo(ConnectionInfo(host_address), shard_num, replica_num)
+            for (host_address, shard_num, replica_num) in bootstrap_client.execute(
                 """
-                SELECT host_address, port, shard_num, replica_num
+                SELECT host_address, shard_num, replica_num
                 FROM system.clusters
                 WHERE name = %(name)s
                 ORDER BY shard_num, replica_num
@@ -87,7 +89,7 @@ def __init__(self, bootstrap_client: Client, extra_hosts: Sequence[ConnectionInf
     def __get_task_function(self, host: HostInfo, fn: Callable[[Client], T]) -> Callable[[], T]:
         pool = self.__pools.get(host)
         if pool is None:
-            pool = self.__pools[host] = make_ch_pool(host=host.connection_info.address, port=host.connection_info.port)
+            pool = self.__pools[host] = host.connection_info.make_pool()
 
         def task():
             with pool.get_client() as client:
diff --git a/posthog/clickhouse/materialized_columns.py b/posthog/clickhouse/materialized_columns.py
index 2ff858274ab4d..09b2d8b24c6dc 100644
--- a/posthog/clickhouse/materialized_columns.py
+++ b/posthog/clickhouse/materialized_columns.py
@@ -1,6 +1,6 @@
-from datetime import timedelta
+from typing import Protocol
 
-from posthog.cache_utils import cache_for
+from posthog.models.instance_setting import get_instance_setting
 from posthog.models.property import PropertyName, TableColumn, TableWithProperties
 from posthog.settings import EE_AVAILABLE
 
@@ -8,19 +8,25 @@
 ColumnName = str
 TablesWithMaterializedColumns = TableWithProperties
 
+
+class MaterializedColumn(Protocol):
+    name: ColumnName
+    is_nullable: bool
+
+
 if EE_AVAILABLE:
-    from ee.clickhouse.materialized_columns.columns import get_materialized_columns
-else:
+    from ee.clickhouse.materialized_columns.columns import get_enabled_materialized_columns
 
-    def get_materialized_columns(
-        table: TablesWithMaterializedColumns,
-        exclude_disabled_columns: bool = False,
-    ) -> dict[tuple[PropertyName, TableColumn], ColumnName]:
-        return {}
+    def get_materialized_column_for_property(
+        table: TablesWithMaterializedColumns, table_column: TableColumn, property_name: PropertyName
+    ) -> MaterializedColumn | None:
+        if not get_instance_setting("MATERIALIZED_COLUMNS_ENABLED"):
+            return None
 
+        return get_enabled_materialized_columns(table).get((property_name, table_column))
+else:
 
-@cache_for(timedelta(minutes=15))
-def get_enabled_materialized_columns(
-    table: TablesWithMaterializedColumns,
-) -> dict[tuple[PropertyName, TableColumn], ColumnName]:
-    return get_materialized_columns(table, exclude_disabled_columns=True)
+    def get_materialized_column_for_property(
+        table: TablesWithMaterializedColumns, table_column: TableColumn, property_name: PropertyName
+    ) -> MaterializedColumn | None:
+        return None
diff --git a/posthog/clickhouse/migrations/0026_fix_materialized_window_and_session_ids.py b/posthog/clickhouse/migrations/0026_fix_materialized_window_and_session_ids.py
index 7e7847c570bac..1be2a1c033c66 100644
--- a/posthog/clickhouse/migrations/0026_fix_materialized_window_and_session_ids.py
+++ b/posthog/clickhouse/migrations/0026_fix_materialized_window_and_session_ids.py
@@ -1,6 +1,6 @@
 from infi.clickhouse_orm import migrations
 
-from posthog.clickhouse.materialized_columns import get_materialized_columns
+from posthog.clickhouse.materialized_columns import get_materialized_column_for_property
 from posthog.client import sync_execute
 from posthog.settings import CLICKHOUSE_CLUSTER
 
@@ -45,9 +45,9 @@ def materialize_session_and_window_id(database):
 
     properties = ["$session_id", "$window_id"]
     for property_name in properties:
-        materialized_columns = get_materialized_columns("events")
+        current_materialized_column = get_materialized_column_for_property("events", "properties", property_name)
         # If the column is not materialized, materialize it
-        if (property_name, "properties") not in materialized_columns:
+        if current_materialized_column is None:
             materialize("events", property_name, property_name)
 
         # Now, we need to clean up any potentail inconsistencies with existing column names
@@ -71,9 +71,8 @@ def materialize_session_and_window_id(database):
         # materialized the column or renamed the column, and then ran the 0004_...  async migration
         # before this migration runs.
         possible_old_column_names = {"mat_" + property_name}
-        current_materialized_column_name = materialized_columns.get((property_name, "properties"), None)
-        if current_materialized_column_name is not None and current_materialized_column_name != property_name:
-            possible_old_column_names.add(current_materialized_column_name)
+        if current_materialized_column is not None and current_materialized_column.name != property_name:
+            possible_old_column_names.add(current_materialized_column.name)
 
         for possible_old_column_name in possible_old_column_names:
             ensure_only_new_column_exists(database, "sharded_events", possible_old_column_name, property_name)
diff --git a/posthog/clickhouse/migrations/0094_add_replay_all_urls.py b/posthog/clickhouse/migrations/0094_add_replay_all_urls.py
new file mode 100644
index 0000000000000..6906c3971cbdd
--- /dev/null
+++ b/posthog/clickhouse/migrations/0094_add_replay_all_urls.py
@@ -0,0 +1,26 @@
+from posthog.clickhouse.client.migration_tools import run_sql_with_exceptions
+from posthog.session_recordings.sql.session_replay_event_migrations_sql import (
+    DROP_SESSION_REPLAY_EVENTS_TABLE_MV_SQL,
+    DROP_KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL,
+    ADD_ALL_URLS_SESSION_REPLAY_EVENTS_TABLE_SQL,
+    ADD_ALL_URLS_WRITABLE_SESSION_REPLAY_EVENTS_TABLE_SQL,
+    ADD_ALL_URLS_DISTRIBUTED_SESSION_REPLAY_EVENTS_TABLE_SQL,
+)
+from posthog.session_recordings.sql.session_replay_event_sql import (
+    SESSION_REPLAY_EVENTS_TABLE_MV_SQL,
+    KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL,
+)
+
+operations = [
+    # we have to drop materialized view first so that we're no longer pulling from kakfa
+    # then we drop the kafka table
+    run_sql_with_exceptions(DROP_SESSION_REPLAY_EVENTS_TABLE_MV_SQL()),
+    run_sql_with_exceptions(DROP_KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    # now we can alter the target tables
+    run_sql_with_exceptions(ADD_ALL_URLS_DISTRIBUTED_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    run_sql_with_exceptions(ADD_ALL_URLS_WRITABLE_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    run_sql_with_exceptions(ADD_ALL_URLS_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    # and then recreate the materialized views and kafka tables
+    run_sql_with_exceptions(KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    run_sql_with_exceptions(SESSION_REPLAY_EVENTS_TABLE_MV_SQL()),
+]
diff --git a/posthog/clickhouse/migrations/0095_add_snapshot_library_tracking.py b/posthog/clickhouse/migrations/0095_add_snapshot_library_tracking.py
new file mode 100644
index 0000000000000..42391c66fa059
--- /dev/null
+++ b/posthog/clickhouse/migrations/0095_add_snapshot_library_tracking.py
@@ -0,0 +1,26 @@
+from posthog.clickhouse.client.migration_tools import run_sql_with_exceptions
+from posthog.session_recordings.sql.session_replay_event_migrations_sql import (
+    DROP_SESSION_REPLAY_EVENTS_TABLE_MV_SQL,
+    DROP_KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL,
+    ADD_LIBRARY_SESSION_REPLAY_EVENTS_TABLE_SQL,
+    ADD_LIBRARY_WRITABLE_SESSION_REPLAY_EVENTS_TABLE_SQL,
+    ADD_LIBRARY_DISTRIBUTED_SESSION_REPLAY_EVENTS_TABLE_SQL,
+)
+from posthog.session_recordings.sql.session_replay_event_sql import (
+    SESSION_REPLAY_EVENTS_TABLE_MV_SQL,
+    KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL,
+)
+
+operations = [
+    # we have to drop materialized view first so that we're no longer pulling from kakfa
+    # then we drop the kafka table
+    run_sql_with_exceptions(DROP_SESSION_REPLAY_EVENTS_TABLE_MV_SQL()),
+    run_sql_with_exceptions(DROP_KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    # now we can alter the target tables
+    run_sql_with_exceptions(ADD_LIBRARY_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    run_sql_with_exceptions(ADD_LIBRARY_DISTRIBUTED_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    run_sql_with_exceptions(ADD_LIBRARY_WRITABLE_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    # and then recreate the materialized views and kafka tables
+    run_sql_with_exceptions(KAFKA_SESSION_REPLAY_EVENTS_TABLE_SQL()),
+    run_sql_with_exceptions(SESSION_REPLAY_EVENTS_TABLE_MV_SQL()),
+]
diff --git a/posthog/clickhouse/test/__snapshots__/test_schema.ambr b/posthog/clickhouse/test/__snapshots__/test_schema.ambr
index dce8f35d13843..406f73008fd28 100644
--- a/posthog/clickhouse/test/__snapshots__/test_schema.ambr
+++ b/posthog/clickhouse/test/__snapshots__/test_schema.ambr
@@ -470,6 +470,7 @@
       first_timestamp DateTime64(6, 'UTC'),
       last_timestamp DateTime64(6, 'UTC'),
       first_url Nullable(VARCHAR),
+      urls Array(String),
       click_count Int64,
       keypress_count Int64,
       mouse_activity_count Int64,
@@ -480,7 +481,8 @@
       size Int64,
       event_count Int64,
       message_count Int64,
-      snapshot_source LowCardinality(Nullable(String))
+      snapshot_source LowCardinality(Nullable(String)),
+      snapshot_library Nullable(String)
   ) ENGINE = Kafka('test.kafka.broker:9092', 'clickhouse_session_replay_events_test', 'group1', 'JSONEachRow')
   
   '''
@@ -1484,6 +1486,7 @@
       first_timestamp DateTime64(6, 'UTC'),
       last_timestamp DateTime64(6, 'UTC'),
       first_url Nullable(VARCHAR),
+      urls Array(String),
       click_count Int64,
       keypress_count Int64,
       mouse_activity_count Int64,
@@ -1494,7 +1497,8 @@
       size Int64,
       event_count Int64,
       message_count Int64,
-      snapshot_source LowCardinality(Nullable(String))
+      snapshot_source LowCardinality(Nullable(String)),
+      snapshot_library Nullable(String)
   ) ENGINE = Kafka('kafka:9092', 'clickhouse_session_replay_events_test', 'group1', 'JSONEachRow')
   
   '''
@@ -2175,7 +2179,11 @@
       distinct_id VARCHAR,
       min_first_timestamp SimpleAggregateFunction(min, DateTime64(6, 'UTC')),
       max_last_timestamp SimpleAggregateFunction(max, DateTime64(6, 'UTC')),
+      -- store the first url of the session so we can quickly show that in playlists
       first_url AggregateFunction(argMin, Nullable(VARCHAR), DateTime64(6, 'UTC')),
+      -- but also store each url so we can query by visited page without having to scan all events
+      -- despite the name we can put mobile screens in here as well to give same functionality across platforms
+      all_urls SimpleAggregateFunction(groupUniqArrayArray, Array(String)),
       click_count SimpleAggregateFunction(sum, Int64),
       keypress_count SimpleAggregateFunction(sum, Int64),
       mouse_activity_count SimpleAggregateFunction(sum, Int64),
@@ -2192,8 +2200,10 @@
       -- often very useful in incidents or debugging
       -- because we batch events we expect message_count to be lower than event_count
       event_count SimpleAggregateFunction(sum, Int64),
-      -- which source the snapshots came from Android, iOS, Mobile, Web. Web if absent
+      -- which source the snapshots came from Mobile or Web. Web if absent
       snapshot_source AggregateFunction(argMin, LowCardinality(Nullable(String)), DateTime64(6, 'UTC')),
+      -- knowing something is mobile isn't enough, we need to know if e.g. RN or flutter
+      snapshot_library AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
       _timestamp SimpleAggregateFunction(max, DateTime)
   ) ENGINE = Distributed('posthog', 'posthog_test', 'sharded_session_replay_events', sipHash64(distinct_id))
   
@@ -2208,12 +2218,14 @@
   `min_first_timestamp` DateTime64(6, 'UTC'),
   `max_last_timestamp` DateTime64(6, 'UTC'),
   `first_url` AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
+  `all_urls` SimpleAggregateFunction(groupUniqArrayArray, Array(String)),
   `click_count` Int64, `keypress_count` Int64,
   `mouse_activity_count` Int64, `active_milliseconds` Int64,
   `console_log_count` Int64, `console_warn_count` Int64,
   `console_error_count` Int64, `size` Int64, `message_count` Int64,
   `event_count` Int64,
   `snapshot_source` AggregateFunction(argMin, LowCardinality(Nullable(String)), DateTime64(6, 'UTC')),
+  `snapshot_library` AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
   `_timestamp` Nullable(DateTime)
   )
   AS SELECT
@@ -2232,6 +2244,7 @@
   -- this is an aggregate function, not a simple aggregate function
   -- so we have to write to argMinState, and query with argMinMerge
   argMinState(first_url, first_timestamp) as first_url,
+  groupUniqArrayArray(urls) as all_urls,
   sum(click_count) as click_count,
   sum(keypress_count) as keypress_count,
   sum(mouse_activity_count) as mouse_activity_count,
@@ -2244,6 +2257,7 @@
   sum(message_count) as message_count,
   sum(event_count) as event_count,
   argMinState(snapshot_source, first_timestamp) as snapshot_source,
+  argMinState(snapshot_library, first_timestamp) as snapshot_library,
   max(_timestamp) as _timestamp
   FROM posthog_test.kafka_session_replay_events
   group by session_id, team_id
@@ -2758,7 +2772,11 @@
       distinct_id VARCHAR,
       min_first_timestamp SimpleAggregateFunction(min, DateTime64(6, 'UTC')),
       max_last_timestamp SimpleAggregateFunction(max, DateTime64(6, 'UTC')),
+      -- store the first url of the session so we can quickly show that in playlists
       first_url AggregateFunction(argMin, Nullable(VARCHAR), DateTime64(6, 'UTC')),
+      -- but also store each url so we can query by visited page without having to scan all events
+      -- despite the name we can put mobile screens in here as well to give same functionality across platforms
+      all_urls SimpleAggregateFunction(groupUniqArrayArray, Array(String)),
       click_count SimpleAggregateFunction(sum, Int64),
       keypress_count SimpleAggregateFunction(sum, Int64),
       mouse_activity_count SimpleAggregateFunction(sum, Int64),
@@ -2775,8 +2793,10 @@
       -- often very useful in incidents or debugging
       -- because we batch events we expect message_count to be lower than event_count
       event_count SimpleAggregateFunction(sum, Int64),
-      -- which source the snapshots came from Android, iOS, Mobile, Web. Web if absent
+      -- which source the snapshots came from Mobile or Web. Web if absent
       snapshot_source AggregateFunction(argMin, LowCardinality(Nullable(String)), DateTime64(6, 'UTC')),
+      -- knowing something is mobile isn't enough, we need to know if e.g. RN or flutter
+      snapshot_library AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
       _timestamp SimpleAggregateFunction(max, DateTime)
   ) ENGINE = ReplicatedAggregatingMergeTree('/clickhouse/tables/77f1df52-4b43-11e9-910f-b8ca3a9b9f3e_{shard}/posthog.session_replay_events', '{replica}')
   
@@ -3944,7 +3964,11 @@
       distinct_id VARCHAR,
       min_first_timestamp SimpleAggregateFunction(min, DateTime64(6, 'UTC')),
       max_last_timestamp SimpleAggregateFunction(max, DateTime64(6, 'UTC')),
+      -- store the first url of the session so we can quickly show that in playlists
       first_url AggregateFunction(argMin, Nullable(VARCHAR), DateTime64(6, 'UTC')),
+      -- but also store each url so we can query by visited page without having to scan all events
+      -- despite the name we can put mobile screens in here as well to give same functionality across platforms
+      all_urls SimpleAggregateFunction(groupUniqArrayArray, Array(String)),
       click_count SimpleAggregateFunction(sum, Int64),
       keypress_count SimpleAggregateFunction(sum, Int64),
       mouse_activity_count SimpleAggregateFunction(sum, Int64),
@@ -3961,8 +3985,10 @@
       -- often very useful in incidents or debugging
       -- because we batch events we expect message_count to be lower than event_count
       event_count SimpleAggregateFunction(sum, Int64),
-      -- which source the snapshots came from Android, iOS, Mobile, Web. Web if absent
+      -- which source the snapshots came from Mobile or Web. Web if absent
       snapshot_source AggregateFunction(argMin, LowCardinality(Nullable(String)), DateTime64(6, 'UTC')),
+      -- knowing something is mobile isn't enough, we need to know if e.g. RN or flutter
+      snapshot_library AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
       _timestamp SimpleAggregateFunction(max, DateTime)
   ) ENGINE = ReplicatedAggregatingMergeTree('/clickhouse/tables/77f1df52-4b43-11e9-910f-b8ca3a9b9f3e_{shard}/posthog.session_replay_events', '{replica}')
   
diff --git a/posthog/constants.py b/posthog/constants.py
index 063d2894a3c12..af2ede6c13e68 100644
--- a/posthog/constants.py
+++ b/posthog/constants.py
@@ -44,8 +44,6 @@ class AvailableFeature(StrEnum):
 TREND_FILTER_TYPE_EVENTS = "events"
 TREND_FILTER_TYPE_DATA_WAREHOUSE = "data_warehouse"
 
-SESSION_RECORDINGS_FILTER_IDS = "session_ids"
-
 TRENDS_CUMULATIVE = "ActionsLineGraphCumulative"
 TRENDS_LINEAR = "ActionsLineGraph"
 TRENDS_TABLE = "ActionsTable"
diff --git a/posthog/demo/matrix/manager.py b/posthog/demo/matrix/manager.py
index 0abc17f32ca08..02536acb3f079 100644
--- a/posthog/demo/matrix/manager.py
+++ b/posthog/demo/matrix/manager.py
@@ -139,7 +139,7 @@ def run_on_team(self, team: Team, user: User):
             print(
                 f"Inferred {event_definition_count} event definitions, {property_definition_count} property definitions, and {event_properties_count} event-property pairs."
             )
-        for cohort in Cohort.objects.filter(team=team):
+        for cohort in Cohort.objects.filter(team__project_id=team.project_id):
             cohort.calculate_people_ch(pending_version=0)
         team.project.save()
         team.save()
@@ -204,7 +204,7 @@ def _erase_master_team_data(cls):
         #         )
         #     ]
         # )
-        GroupTypeMapping.objects.filter(team_id=cls.MASTER_TEAM_ID).delete()
+        GroupTypeMapping.objects.filter(project_id=cls.MASTER_TEAM_ID).delete()
 
     def _copy_analytics_data_from_master_team(self, target_team: Team):
         from posthog.models.event.sql import COPY_EVENTS_BETWEEN_TEAMS
@@ -222,11 +222,11 @@ def _copy_analytics_data_from_master_team(self, target_team: Team):
         sync_execute(COPY_PERSON_DISTINCT_ID2S_BETWEEN_TEAMS, copy_params)
         sync_execute(COPY_EVENTS_BETWEEN_TEAMS, copy_params)
         sync_execute(COPY_GROUPS_BETWEEN_TEAMS, copy_params)
-        GroupTypeMapping.objects.filter(team_id=target_team.pk).delete()
+        GroupTypeMapping.objects.filter(project_id=target_team.project_id).delete()
         GroupTypeMapping.objects.bulk_create(
             (
-                GroupTypeMapping(team=target_team, project_id=target_team.project_id, **record)
-                for record in GroupTypeMapping.objects.filter(team_id=self.MASTER_TEAM_ID).values(
+                GroupTypeMapping(team_id=target_team.id, project_id=target_team.project_id, **record)
+                for record in GroupTypeMapping.objects.filter(project_id=self.MASTER_TEAM_ID).values(
                     "group_type", "group_type_index", "name_singular", "name_plural"
                 )
             ),
diff --git a/posthog/demo/products/hedgebox/matrix.py b/posthog/demo/products/hedgebox/matrix.py
index 5990f7a744235..f14c3de924cda 100644
--- a/posthog/demo/products/hedgebox/matrix.py
+++ b/posthog/demo/products/hedgebox/matrix.py
@@ -769,7 +769,7 @@ def set_project_up(self, team, user):
                             )
                         ),
                     )
-                    for insight in Insight.objects.filter(team=team)
+                    for insight in Insight.objects.filter(team__project_id=team.project_id)
                 ),
             )
         except IntegrityError:
diff --git a/posthog/helpers/dashboard_templates.py b/posthog/helpers/dashboard_templates.py
index 0e3f8a81f9536..313f8c6722a2a 100644
--- a/posthog/helpers/dashboard_templates.py
+++ b/posthog/helpers/dashboard_templates.py
@@ -4,22 +4,6 @@
 import structlog
 
 from posthog.constants import (
-    BREAKDOWN,
-    BREAKDOWN_TYPE,
-    DATE_FROM,
-    DISPLAY,
-    FILTER_TEST_ACCOUNTS,
-    INSIGHT,
-    INSIGHT_TRENDS,
-    INTERVAL,
-    PROPERTIES,
-    TREND_FILTER_TYPE_EVENTS,
-    TRENDS_BAR_VALUE,
-    TRENDS_BOLD_NUMBER,
-    TRENDS_LINEAR,
-    TRENDS_TABLE,
-    TRENDS_WORLD_MAP,
-    UNIQUE_USERS,
     AvailableFeature,
     ENRICHED_DASHBOARD_INSIGHT_IDENTIFIER,
 )
@@ -37,7 +21,7 @@
 
 
 def _create_website_dashboard(dashboard: Dashboard) -> None:
-    dashboard.filters = {DATE_FROM: "-30d"}
+    dashboard.filters = {"date_from": "-30d"}
     if dashboard.team.organization.is_feature_available(AvailableFeature.TAGGING):
         tag, _ = Tag.objects.get_or_create(
             name="marketing",
@@ -52,19 +36,28 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Website Unique Users (Total)",
         description="Shows the number of unique users that use your app every day.",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": UNIQUE_USERS,
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                }
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_BOLD_NUMBER,
-            "compare": True,
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "compareFilter": {"compare": True},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": [],
+                "series": [{"event": "$pageview", "kind": "EventsNode", "math": "dau", "name": "$pageview"}],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "BoldNumber",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
+            },
         },
         layouts={
             "sm": {"i": "21", "x": 0, "y": 0, "w": 6, "h": 5, "minW": 3, "minH": 5},
@@ -85,40 +78,43 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Organic SEO Unique Users (Total)",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": UNIQUE_USERS,
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                }
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_BOLD_NUMBER,
-            "compare": True,
-            PROPERTIES: {
-                "type": "AND",
-                "values": [
-                    {
-                        "type": "AND",
-                        "values": [
-                            {
-                                "key": "$referring_domain",
-                                "type": "event",
-                                "value": "google",
-                                "operator": "icontains",
-                            },
-                            {
-                                "key": "utm_source",
-                                "type": "event",
-                                "value": "is_not_set",
-                                "operator": "is_not_set",
-                            },
-                        ],
-                    }
-                ],
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "compareFilter": {"compare": True},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": {
+                    "type": "AND",
+                    "values": [
+                        {
+                            "type": "AND",
+                            "values": [
+                                {
+                                    "key": "$referring_domain",
+                                    "operator": "icontains",
+                                    "type": "event",
+                                    "value": "google",
+                                },
+                                {"key": "utm_source", "operator": "is_not_set", "type": "event", "value": "is_not_set"},
+                            ],
+                        }
+                    ],
+                },
+                "series": [{"event": "$pageview", "kind": "EventsNode", "math": "dau", "name": "$pageview"}],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "BoldNumber",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
             },
         },
         layouts={
@@ -141,18 +137,27 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Website Unique Users (Breakdown)",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": UNIQUE_USERS,
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                }
-            ],
-            INTERVAL: "week",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: "ActionsBar",
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "week",
+                "kind": "TrendsQuery",
+                "properties": [],
+                "series": [{"event": "$pageview", "kind": "EventsNode", "math": "dau", "name": "$pageview"}],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsBar",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
+            },
         },
         layouts={
             "sm": {"i": "23", "x": 0, "y": 5, "w": 6, "h": 5, "minW": 3, "minH": 5},
@@ -173,32 +178,38 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Organic SEO Unique Users (Breakdown)",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": UNIQUE_USERS,
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    PROPERTIES: [
-                        {
-                            "key": "$referring_domain",
-                            "type": "event",
-                            "value": "google",
-                            "operator": "icontains",
-                        },
-                        {
-                            "key": "utm_source",
-                            "type": "event",
-                            "value": "is_not_set",
-                            "operator": "is_not_set",
-                        },
-                    ],
-                }
-            ],
-            INTERVAL: "week",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: "ActionsBar",
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "week",
+                "kind": "TrendsQuery",
+                "properties": [],
+                "series": [
+                    {
+                        "event": "$pageview",
+                        "kind": "EventsNode",
+                        "math": "dau",
+                        "name": "$pageview",
+                        "properties": [
+                            {"key": "$referring_domain", "operator": "icontains", "type": "event", "value": "google"},
+                            {"key": "utm_source", "operator": "is_not_set", "type": "event", "value": "is_not_set"},
+                        ],
+                    }
+                ],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsBar",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
+            },
         },
         layouts={
             "sm": {"i": "24", "x": 6, "y": 5, "w": 6, "h": 5, "minW": 3, "minH": 5},
@@ -213,30 +224,31 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Sessions Per User",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": UNIQUE_USERS,
-                    "name": "$pageview",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "order": 0,
-                    PROPERTIES: [],
-                },
-                {
-                    "id": "$pageview",
-                    "math": "unique_session",
-                    "name": "$pageview",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "order": 1,
-                    PROPERTIES: [],
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "week",
+                "kind": "TrendsQuery",
+                "properties": [],
+                "series": [
+                    {"event": "$pageview", "kind": "EventsNode", "math": "dau", "name": "$pageview"},
+                    {"event": "$pageview", "kind": "EventsNode", "math": "unique_session", "name": "$pageview"},
+                ],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsLineGraph",
+                    "formula": "B/A",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
                 },
-            ],
-            INTERVAL: "week",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: "ActionsLineGraph",
-            "formula": "B/A",
+            },
         },
         layouts={
             "sm": {"i": "25", "x": 0, "y": 10, "w": 6, "h": 5, "minW": 3, "minH": 5},
@@ -257,30 +269,31 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Pages Per User",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": "total",
-                    "name": "$pageview",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "order": 0,
-                    PROPERTIES: [],
-                },
-                {
-                    "id": "$pageview",
-                    "math": UNIQUE_USERS,
-                    "name": "$pageview",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "order": 1,
-                    PROPERTIES: [],
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "week",
+                "kind": "TrendsQuery",
+                "properties": [],
+                "series": [
+                    {"event": "$pageview", "kind": "EventsNode", "math": "total", "name": "$pageview"},
+                    {"event": "$pageview", "kind": "EventsNode", "math": "dau", "name": "$pageview"},
+                ],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsLineGraph",
+                    "formula": "A/B",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
                 },
-            ],
-            INTERVAL: "week",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: "ActionsLineGraph",
-            "formula": "A/B",
+            },
         },
         layouts={
             "sm": {"i": "26", "x": 6, "y": 10, "w": 6, "h": 5, "minW": 3, "minH": 5},
@@ -303,37 +316,36 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Top Website Pages (Overall)",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": "unique_session",
-                    "name": "$pageview",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "order": 0,
-                }
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_BAR_VALUE,
-            BREAKDOWN: "$current_url",
-            BREAKDOWN_TYPE: "event",
-            PROPERTIES: {
-                "type": "AND",
-                "values": [
-                    {
-                        "type": "AND",
-                        "values": [
-                            {
-                                "key": "$current_url",
-                                "type": "event",
-                                "value": "?",
-                                "operator": "not_icontains",
-                            }
-                        ],
-                    }
-                ],
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown": "$current_url", "breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": {
+                    "type": "AND",
+                    "values": [
+                        {
+                            "type": "AND",
+                            "values": [
+                                {"key": "$current_url", "operator": "not_icontains", "type": "event", "value": "?"}
+                            ],
+                        }
+                    ],
+                },
+                "series": [{"event": "$pageview", "kind": "EventsNode", "math": "unique_session", "name": "$pageview"}],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsBarValue",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
             },
         },
         layouts={
@@ -355,43 +367,42 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Top Website Pages (via Google)",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": "unique_session",
-                    "name": "$pageview",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "order": 0,
-                }
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_BAR_VALUE,
-            BREAKDOWN: "$current_url",
-            BREAKDOWN_TYPE: "event",
-            PROPERTIES: {
-                "type": "AND",
-                "values": [
-                    {
-                        "type": "AND",
-                        "values": [
-                            {
-                                "key": "$current_url",
-                                "type": "event",
-                                "value": "?",
-                                "operator": "not_icontains",
-                            },
-                            {
-                                "key": "$referring_domain",
-                                "type": "event",
-                                "value": "google",
-                                "operator": "icontains",
-                            },
-                        ],
-                    }
-                ],
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown": "$current_url", "breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": {
+                    "type": "AND",
+                    "values": [
+                        {
+                            "type": "AND",
+                            "values": [
+                                {"key": "$current_url", "operator": "not_icontains", "type": "event", "value": "?"},
+                                {
+                                    "key": "$referring_domain",
+                                    "operator": "icontains",
+                                    "type": "event",
+                                    "value": "google",
+                                },
+                            ],
+                        }
+                    ],
+                },
+                "series": [{"event": "$pageview", "kind": "EventsNode", "math": "unique_session", "name": "$pageview"}],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsBarValue",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
             },
         },
         layouts={
@@ -407,22 +418,27 @@ def _create_website_dashboard(dashboard: Dashboard) -> None:
         dashboard,
         name="Website Users by Location",
         description="",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$pageview",
-                    "math": UNIQUE_USERS,
-                    "name": "$pageview",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "order": 0,
-                }
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_WORLD_MAP,
-            BREAKDOWN: "$geoip_country_code",
-            BREAKDOWN_TYPE: "person",
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown": "$geoip_country_code", "breakdown_type": "person"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": [],
+                "series": [{"event": "$pageview", "kind": "EventsNode", "math": "dau", "name": "$pageview"}],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "WorldMap",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
+            },
         },
         layouts={
             "sm": {"i": "29", "x": 0, "y": 23, "w": 12, "h": 8, "minW": 3, "minH": 5},
@@ -471,11 +487,9 @@ def create_from_template(dashboard: Dashboard, template: DashboardTemplate) -> N
     for template_tile in template.tiles:
         if template_tile["type"] == "INSIGHT":
             query = template_tile.get("query", None)
-            filters = template_tile.get("filters") if not query else {}
             _create_tile_for_insight(
                 dashboard,
                 name=template_tile.get("name"),
-                filters=filters,
                 query=query,
                 description=template_tile.get("description"),
                 color=template_tile.get("color"),
@@ -508,18 +522,15 @@ def _create_tile_for_text(dashboard: Dashboard, body: str, layouts: dict, color:
 def _create_tile_for_insight(
     dashboard: Dashboard,
     name: str,
-    filters: dict,
     description: str,
     layouts: dict,
     color: Optional[str],
     query: Optional[dict] = None,
 ) -> None:
-    filter_test_accounts = filters.get("filter_test_accounts", True)
     insight = Insight.objects.create(
         team=dashboard.team,
         name=name,
         description=description,
-        filters={**filters, "filter_test_accounts": filter_test_accounts},
         is_sample=True,
         query=query,
     )
@@ -547,7 +558,7 @@ def create_dashboard_from_template(template_key: str, dashboard: Dashboard) -> N
 
 
 def create_feature_flag_dashboard(feature_flag, dashboard: Dashboard) -> None:
-    dashboard.filters = {DATE_FROM: "-30d"}
+    dashboard.filters = {"date_from": "-30d"}
     if dashboard.team.organization.is_feature_available(AvailableFeature.TAGGING):
         tag, _ = Tag.objects.get_or_create(
             name="feature flags",
@@ -562,36 +573,42 @@ def create_feature_flag_dashboard(feature_flag, dashboard: Dashboard) -> None:
         dashboard,
         name="Feature Flag Called Total Volume",
         description="Shows the number of total calls made on feature flag with key: " + feature_flag.key,
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$feature_flag_called",
-                    "name": "$feature_flag_called",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                }
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_LINEAR,
-            PROPERTIES: {
-                "type": "AND",
-                "values": [
-                    {
-                        "type": "AND",
-                        "values": [
-                            {
-                                "key": "$feature_flag",
-                                "type": "event",
-                                "value": feature_flag.key,
-                            },
-                        ],
-                    }
-                ],
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown": "$feature_flag_response", "breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": {
+                    "type": "AND",
+                    "values": [
+                        {
+                            "type": "AND",
+                            "values": [
+                                {
+                                    "key": "$feature_flag",
+                                    "operator": "exact",
+                                    "type": "event",
+                                    "value": feature_flag.key,
+                                }
+                            ],
+                        }
+                    ],
+                },
+                "series": [{"event": "$feature_flag_called", "kind": "EventsNode", "name": "$feature_flag_called"}],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsLineGraph",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
             },
-            BREAKDOWN: "$feature_flag_response",
-            BREAKDOWN_TYPE: "event",
-            FILTER_TEST_ACCOUNTS: False,
         },
         layouts={
             "sm": {"i": "21", "x": 0, "y": 0, "w": 6, "h": 5, "minW": 3, "minH": 5},
@@ -613,37 +630,49 @@ def create_feature_flag_dashboard(feature_flag, dashboard: Dashboard) -> None:
         name="Feature Flag calls made by unique users per variant",
         description="Shows the number of unique user calls made on feature flag per variant with key: "
         + feature_flag.key,
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$feature_flag_called",
-                    "name": "$feature_flag_called",
-                    "math": UNIQUE_USERS,
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                }
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_TABLE,
-            PROPERTIES: {
-                "type": "AND",
-                "values": [
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown": "$feature_flag_response", "breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": {
+                    "type": "AND",
+                    "values": [
+                        {
+                            "type": "AND",
+                            "values": [
+                                {
+                                    "key": "$feature_flag",
+                                    "operator": "exact",
+                                    "type": "event",
+                                    "value": feature_flag.key,
+                                }
+                            ],
+                        }
+                    ],
+                },
+                "series": [
                     {
-                        "type": "AND",
-                        "values": [
-                            {
-                                "key": "$feature_flag",
-                                "type": "event",
-                                "value": feature_flag.key,
-                            },
-                        ],
+                        "event": "$feature_flag_called",
+                        "kind": "EventsNode",
+                        "math": "dau",
+                        "name": "$feature_flag_called",
                     }
                 ],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsTable",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
             },
-            BREAKDOWN: "$feature_flag_response",
-            BREAKDOWN_TYPE: "event",
-            FILTER_TEST_ACCOUNTS: False,
         },
         layouts={
             "sm": {"i": "22", "x": 6, "y": 0, "w": 6, "h": 5, "minW": 3, "minH": 5},
@@ -667,40 +696,45 @@ def add_enriched_insights_to_feature_flag_dashboard(feature_flag, dashboard: Das
         dashboard,
         name=f"{ENRICHED_DASHBOARD_INSIGHT_IDENTIFIER} Total Volume",
         description="Shows the total number of times this feature was viewed and interacted with",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$feature_view",
-                    "name": "Feature View - Total",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                },
-                {
-                    "id": "$feature_view",
-                    "name": "Feature View - Unique users",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "math": UNIQUE_USERS,
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": {
+                    "type": "AND",
+                    "values": [
+                        {
+                            "type": "AND",
+                            "values": [
+                                {"key": "feature_flag", "operator": "exact", "type": "event", "value": feature_flag.key}
+                            ],
+                        }
+                    ],
                 },
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_LINEAR,
-            PROPERTIES: {
-                "type": "AND",
-                "values": [
+                "series": [
+                    {"event": "$feature_view", "kind": "EventsNode", "name": "Feature View - Total"},
                     {
-                        "type": "AND",
-                        "values": [
-                            {
-                                "key": "feature_flag",
-                                "type": "event",
-                                "value": feature_flag.key,
-                            },
-                        ],
-                    }
+                        "event": "$feature_view",
+                        "kind": "EventsNode",
+                        "math": "dau",
+                        "name": "Feature View - Unique users",
+                    },
                 ],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsLineGraph",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
             },
-            FILTER_TEST_ACCOUNTS: False,
         },
         layouts={},
         color=None,
@@ -710,40 +744,45 @@ def add_enriched_insights_to_feature_flag_dashboard(feature_flag, dashboard: Das
         dashboard,
         name="Feature Interaction Total Volume",
         description="Shows the total number of times this feature was viewed and interacted with",
-        filters={
-            TREND_FILTER_TYPE_EVENTS: [
-                {
-                    "id": "$feature_interaction",
-                    "name": "Feature Interaction - Total",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                },
-                {
-                    "id": "$feature_interaction",
-                    "name": "Feature Interaction - Unique users",
-                    "type": TREND_FILTER_TYPE_EVENTS,
-                    "math": UNIQUE_USERS,
+        query={
+            "kind": "InsightVizNode",
+            "source": {
+                "breakdownFilter": {"breakdown_type": "event"},
+                "dateRange": {"date_from": "-30d", "explicitDate": False},
+                "filterTestAccounts": False,
+                "interval": "day",
+                "kind": "TrendsQuery",
+                "properties": {
+                    "type": "AND",
+                    "values": [
+                        {
+                            "type": "AND",
+                            "values": [
+                                {"key": "feature_flag", "operator": "exact", "type": "event", "value": feature_flag.key}
+                            ],
+                        }
+                    ],
                 },
-            ],
-            INTERVAL: "day",
-            INSIGHT: INSIGHT_TRENDS,
-            DATE_FROM: "-30d",
-            DISPLAY: TRENDS_LINEAR,
-            PROPERTIES: {
-                "type": "AND",
-                "values": [
+                "series": [
+                    {"event": "$feature_interaction", "kind": "EventsNode", "name": "Feature Interaction - Total"},
                     {
-                        "type": "AND",
-                        "values": [
-                            {
-                                "key": "feature_flag",
-                                "type": "event",
-                                "value": feature_flag.key,
-                            },
-                        ],
-                    }
+                        "event": "$feature_interaction",
+                        "kind": "EventsNode",
+                        "math": "dau",
+                        "name": "Feature Interaction - Unique users",
+                    },
                 ],
+                "trendsFilter": {
+                    "aggregationAxisFormat": "numeric",
+                    "display": "ActionsLineGraph",
+                    "showAlertThresholdLines": False,
+                    "showLegend": False,
+                    "showPercentStackView": False,
+                    "showValuesOnSeries": False,
+                    "smoothingIntervals": 1,
+                    "yAxisScaleType": "linear",
+                },
             },
-            FILTER_TEST_ACCOUNTS: False,
         },
         layouts={},
         color=None,
diff --git a/posthog/hogql/ast.py b/posthog/hogql/ast.py
index 2e439e89ccc38..092c926d40631 100644
--- a/posthog/hogql/ast.py
+++ b/posthog/hogql/ast.py
@@ -840,6 +840,9 @@ class SelectSetQuery(Expr):
     initial_select_query: Union[SelectQuery, "SelectSetQuery"]
     subsequent_select_queries: list[SelectSetNode]
 
+    def select_queries(self):
+        return [self.initial_select_query] + [node.select_query for node in self.subsequent_select_queries]
+
     @classmethod
     def create_from_queries(
         cls, queries: Sequence[Union[SelectQuery, "SelectSetQuery"]], set_operator: SetOperator
diff --git a/posthog/hogql/context.py b/posthog/hogql/context.py
index 615aedc8d2f6c..5f5f8a3666752 100644
--- a/posthog/hogql/context.py
+++ b/posthog/hogql/context.py
@@ -1,4 +1,5 @@
 from dataclasses import dataclass, field
+from functools import cached_property
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 from posthog.hogql.timings import HogQLTimings
@@ -94,3 +95,12 @@ def add_error(
     ):
         if not any(n.start == start and n.end == end and n.message == message and n.fix == fix for n in self.errors):
             self.errors.append(HogQLNotice(start=start, end=end, message=message, fix=fix))
+
+    @cached_property
+    def project_id(self) -> int:
+        from posthog.models import Team
+
+        if not self.team and not self.team_id:
+            raise ValueError("Either team or team_id must be set to determine project_id")
+        team = self.team or Team.objects.only("project_id").get(id=self.team_id)
+        return team.project_id
diff --git a/posthog/hogql/database/database.py b/posthog/hogql/database/database.py
index 94f9e1729ac41..dd8ffc8a377a9 100644
--- a/posthog/hogql/database/database.py
+++ b/posthog/hogql/database/database.py
@@ -28,6 +28,7 @@
     Table,
     VirtualTable,
 )
+from posthog.hogql.database.schema.app_metrics2 import AppMetrics2Table
 from posthog.hogql.database.schema.channel_type import create_initial_channel_type, create_initial_domain_type
 from posthog.hogql.database.schema.cohort_people import CohortPeople, RawCohortPeople
 from posthog.hogql.database.schema.events import EventsTable
@@ -44,6 +45,11 @@
     RawPersonDistinctIdOverridesTable,
     join_with_person_distinct_id_overrides_table,
 )
+from posthog.hogql.database.schema.error_tracking_issue_fingerprint_overrides import (
+    ErrorTrackingIssueFingerprintOverridesTable,
+    RawErrorTrackingIssueFingerprintOverridesTable,
+    join_with_error_tracking_issue_fingerprint_overrides_table,
+)
 from posthog.hogql.database.schema.person_distinct_ids import (
     PersonDistinctIdsTable,
     RawPersonDistinctIdsTable,
@@ -53,6 +59,7 @@
     RawPersonsTable,
     join_with_persons_table,
 )
+from posthog.hogql.database.schema.query_log import QueryLogTable, RawQueryLogTable
 from posthog.hogql.database.schema.session_replay_events import (
     RawSessionReplayEventsTable,
     SessionReplayEventsTable,
@@ -103,11 +110,16 @@ class Database(BaseModel):
     persons: PersonsTable = PersonsTable()
     person_distinct_ids: PersonDistinctIdsTable = PersonDistinctIdsTable()
     person_distinct_id_overrides: PersonDistinctIdOverridesTable = PersonDistinctIdOverridesTable()
+    error_tracking_issue_fingerprint_overrides: ErrorTrackingIssueFingerprintOverridesTable = (
+        ErrorTrackingIssueFingerprintOverridesTable()
+    )
 
     session_replay_events: SessionReplayEventsTable = SessionReplayEventsTable()
     cohort_people: CohortPeople = CohortPeople()
     static_cohort_people: StaticCohortPeople = StaticCohortPeople()
     log_entries: LogEntriesTable = LogEntriesTable()
+    query_log: QueryLogTable = QueryLogTable()
+    app_metrics: AppMetrics2Table = AppMetrics2Table()
     console_logs_log_entries: ReplayConsoleLogsLogEntriesTable = ReplayConsoleLogsLogEntriesTable()
     batch_export_log_entries: BatchExportLogEntriesTable = BatchExportLogEntriesTable()
     sessions: Union[SessionsTableV1, SessionsTableV2] = SessionsTableV1()
@@ -119,7 +131,11 @@ class Database(BaseModel):
     raw_groups: RawGroupsTable = RawGroupsTable()
     raw_cohort_people: RawCohortPeople = RawCohortPeople()
     raw_person_distinct_id_overrides: RawPersonDistinctIdOverridesTable = RawPersonDistinctIdOverridesTable()
+    raw_error_tracking_issue_fingerprint_overrides: RawErrorTrackingIssueFingerprintOverridesTable = (
+        RawErrorTrackingIssueFingerprintOverridesTable()
+    )
     raw_sessions: Union[RawSessionsTableV1, RawSessionsTableV2] = RawSessionsTableV1()
+    raw_query_log: RawQueryLogTable = RawQueryLogTable()
 
     # system tables
     numbers: NumbersTable = NumbersTable()
@@ -134,8 +150,10 @@ class Database(BaseModel):
         "cohort_people",
         "static_cohort_people",
         "log_entries",
+        "app_metrics",
         "sessions",
         "heatmaps",
+        "query_log",
     ]
 
     _warehouse_table_names: list[str] = []
@@ -210,6 +228,27 @@ def _use_person_id_from_person_overrides(database: Database) -> None:
     )
 
 
+def _use_error_tracking_issue_id_from_error_tracking_issue_overrides(database: Database) -> None:
+    database.events.fields["event_issue_id"] = ExpressionField(
+        name="event_issue_id",
+        # convert to UUID to match type of `issue_id` on overrides table
+        expr=parse_expr("toUUID(properties.$exception_issue_id)"),
+    )
+    database.events.fields["exception_issue_override"] = LazyJoin(
+        from_field=["fingerprint"],
+        join_table=ErrorTrackingIssueFingerprintOverridesTable(),
+        join_function=join_with_error_tracking_issue_fingerprint_overrides_table,
+    )
+    database.events.fields["issue_id"] = ExpressionField(
+        name="issue_id",
+        expr=parse_expr(
+            # NOTE: assumes `join_use_nulls = 0` (the default), as ``override.fingerprint`` is not Nullable
+            "if(not(empty(exception_issue_override.issue_id)), exception_issue_override.issue_id, event_issue_id)",
+            start=None,
+        ),
+    )
+
+
 def create_hogql_database(
     team_id: int, modifiers: Optional[HogQLQueryModifiers] = None, team_arg: Optional["Team"] = None
 ) -> Database:
@@ -277,6 +316,8 @@ def create_hogql_database(
         )
         cast(LazyJoin, raw_replay_events.fields["events"]).join_table = events
 
+    _use_error_tracking_issue_id_from_error_tracking_issue_overrides(database)
+
     database.persons.fields["$virt_initial_referring_domain_type"] = create_initial_domain_type(
         "$virt_initial_referring_domain_type"
     )
@@ -284,7 +325,7 @@ def create_hogql_database(
         "$virt_initial_channel_type", modifiers.customChannelTypeRules
     )
 
-    for mapping in GroupTypeMapping.objects.filter(team=team):
+    for mapping in GroupTypeMapping.objects.filter(project_id=team.project_id):
         if database.events.fields.get(mapping.group_type) is None:
             database.events.fields[mapping.group_type] = FieldTraverser(chain=[f"group_{mapping.group_type_index}"])
 
@@ -409,9 +450,11 @@ def define_mappings(warehouse: dict[str, Table], get_table: Callable):
                 from_field=from_field,
                 to_field=to_field,
                 join_table=joining_table,
-                join_function=join.join_function_for_experiments()
-                if "events" == join.joining_table_name and join.configuration.get("experiments_optimized")
-                else join.join_function(),
+                join_function=(
+                    join.join_function_for_experiments()
+                    if "events" == join.joining_table_name and join.configuration.get("experiments_optimized")
+                    else join.join_function()
+                ),
             )
 
             if join.source_table_name == "persons":
diff --git a/posthog/hogql/database/schema/app_metrics2.py b/posthog/hogql/database/schema/app_metrics2.py
new file mode 100644
index 0000000000000..323b127cd87b3
--- /dev/null
+++ b/posthog/hogql/database/schema/app_metrics2.py
@@ -0,0 +1,28 @@
+from posthog.hogql.database.models import (
+    Table,
+    IntegerDatabaseField,
+    StringDatabaseField,
+    DateTimeDatabaseField,
+    FieldOrTable,
+)
+
+APP_METRICS2_FIELDS: dict[str, FieldOrTable] = {
+    "team_id": IntegerDatabaseField(name="team_id"),
+    "app_source": StringDatabaseField(name="app_source"),
+    "app_source_id": StringDatabaseField(name="app_source_id"),
+    "instance_id": StringDatabaseField(name="instance_id"),
+    "timestamp": DateTimeDatabaseField(name="timestamp"),
+    "metric_name": StringDatabaseField(name="metric_name"),
+    "metric_kind": StringDatabaseField(name="metric_kind"),
+    "count": IntegerDatabaseField(name="count"),
+}
+
+
+class AppMetrics2Table(Table):
+    fields: dict[str, FieldOrTable] = APP_METRICS2_FIELDS
+
+    def to_printed_clickhouse(self, context):
+        return "app_metrics2"
+
+    def to_printed_hogql(self):
+        return "app_metrics2"
diff --git a/posthog/hogql/database/schema/cohort_people.py b/posthog/hogql/database/schema/cohort_people.py
index 1768aa55b8a50..20886a048f17b 100644
--- a/posthog/hogql/database/schema/cohort_people.py
+++ b/posthog/hogql/database/schema/cohort_people.py
@@ -21,12 +21,12 @@
 }
 
 
-def select_from_cohort_people_table(requested_fields: dict[str, list[str | int]], team_id: int):
+def select_from_cohort_people_table(requested_fields: dict[str, list[str | int]], project_id: int):
     from posthog.hogql import ast
     from posthog.models import Cohort
 
     cohort_tuples = list(
-        Cohort.objects.filter(is_static=False, team_id=team_id)
+        Cohort.objects.filter(is_static=False, team__project_id=project_id)
         .exclude(version__isnull=True)
         .values_list("id", "version")
     )
@@ -76,7 +76,7 @@ class CohortPeople(LazyTable):
     fields: dict[str, FieldOrTable] = COHORT_PEOPLE_FIELDS
 
     def lazy_select(self, table_to_add: LazyTableToAdd, context, node):
-        return select_from_cohort_people_table(table_to_add.fields_accessed, context.team_id)
+        return select_from_cohort_people_table(table_to_add.fields_accessed, context.project_id)
 
     def to_printed_clickhouse(self, context):
         return "cohortpeople"
diff --git a/posthog/hogql/database/schema/error_tracking_issue_fingerprint_overrides.py b/posthog/hogql/database/schema/error_tracking_issue_fingerprint_overrides.py
new file mode 100644
index 0000000000000..aae04d72cfd42
--- /dev/null
+++ b/posthog/hogql/database/schema/error_tracking_issue_fingerprint_overrides.py
@@ -0,0 +1,94 @@
+from posthog.hogql.ast import SelectQuery
+from posthog.hogql.constants import HogQLQuerySettings
+from posthog.hogql.context import HogQLContext
+
+from posthog.hogql.database.argmax import argmax_select
+from posthog.hogql.database.models import (
+    Table,
+    IntegerDatabaseField,
+    StringDatabaseField,
+    BooleanDatabaseField,
+    LazyTable,
+    FieldOrTable,
+    LazyTableToAdd,
+    LazyJoinToAdd,
+)
+from posthog.hogql.errors import ResolutionError
+
+ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES_FIELDS: dict[str, FieldOrTable] = {
+    "team_id": IntegerDatabaseField(name="team_id"),
+    "fingerprint": StringDatabaseField(name="fingerprint"),
+    "issue_id": StringDatabaseField(name="issue_id"),
+}
+
+
+def join_with_error_tracking_issue_fingerprint_overrides_table(
+    join_to_add: LazyJoinToAdd,
+    context: HogQLContext,
+    node: SelectQuery,
+):
+    from posthog.hogql import ast
+
+    if not join_to_add.fields_accessed:
+        raise ResolutionError("No fields requested from error_tracking_issue_fingerprint_overrides")
+    join_expr = ast.JoinExpr(
+        table=select_from_error_tracking_issue_fingerprint_overrides_table(join_to_add.fields_accessed)
+    )
+    join_expr.join_type = "LEFT OUTER JOIN"
+    join_expr.alias = join_to_add.to_table
+    join_expr.constraint = ast.JoinConstraint(
+        expr=ast.CompareOperation(
+            op=ast.CompareOperationOp.Eq,
+            left=ast.Field(chain=[join_to_add.from_table, "properties", "$exception_fingerprint"]),
+            right=ast.Field(chain=[join_to_add.to_table, "fingerprint"]),
+        ),
+        constraint_type="ON",
+    )
+    return join_expr
+
+
+def select_from_error_tracking_issue_fingerprint_overrides_table(requested_fields: dict[str, list[str | int]]):
+    # Always include "issue_id", as it's the key we use to make further joins, and it'd be great if it's available
+    if "issue_id" not in requested_fields:
+        requested_fields = {**requested_fields, "issue_id": ["issue_id"]}
+    select = argmax_select(
+        table_name="raw_error_tracking_issue_fingerprint_overrides",
+        select_fields=requested_fields,
+        group_fields=["fingerprint"],
+        argmax_field="version",
+        deleted_field="is_deleted",
+    )
+    select.settings = HogQLQuerySettings(optimize_aggregation_in_order=True)
+    return select
+
+
+class RawErrorTrackingIssueFingerprintOverridesTable(Table):
+    fields: dict[str, FieldOrTable] = {
+        **ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES_FIELDS,
+        "is_deleted": BooleanDatabaseField(name="is_deleted"),
+        "version": IntegerDatabaseField(name="version"),
+    }
+
+    def to_printed_clickhouse(self, context):
+        return "error_tracking_issue_fingerprint_overrides"
+
+    def to_printed_hogql(self):
+        return "raw_error_tracking_issue_fingerprint_overrides"
+
+
+class ErrorTrackingIssueFingerprintOverridesTable(LazyTable):
+    fields: dict[str, FieldOrTable] = ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES_FIELDS
+
+    def lazy_select(
+        self,
+        table_to_add: LazyTableToAdd,
+        context: HogQLContext,
+        node: SelectQuery,
+    ):
+        return select_from_error_tracking_issue_fingerprint_overrides_table(table_to_add.fields_accessed)
+
+    def to_printed_clickhouse(self, context):
+        return "error_tracking_issue_fingerprint_overrides"
+
+    def to_printed_hogql(self):
+        return "error_tracking_issue_fingerprint_overrides"
diff --git a/posthog/hogql/database/schema/query_log.py b/posthog/hogql/database/schema/query_log.py
new file mode 100644
index 0000000000000..873ebfa50a239
--- /dev/null
+++ b/posthog/hogql/database/schema/query_log.py
@@ -0,0 +1,131 @@
+from typing import Any
+
+from posthog.hogql import ast
+from posthog.hogql.database.models import (
+    IntegerDatabaseField,
+    StringDatabaseField,
+    DateTimeDatabaseField,
+    LazyTable,
+    FieldOrTable,
+    LazyTableToAdd,
+    FloatDatabaseField,
+    FunctionCallTable,
+    BooleanDatabaseField,
+)
+
+QUERY_LOG_FIELDS: dict[str, FieldOrTable] = {
+    "query_id": StringDatabaseField(name="query_id"),
+    "query": StringDatabaseField(name="query"),  #
+    "query_start_time": DateTimeDatabaseField(name="event_time"),  #
+    "query_duration_ms": FloatDatabaseField(name="query_duration_ms"),  #
+    "created_by": IntegerDatabaseField(name="created_by"),
+    "read_rows": IntegerDatabaseField(name="read_rows"),
+    "read_bytes": IntegerDatabaseField(name="read_bytes"),
+    "result_rows": IntegerDatabaseField(name="result_rows"),
+    "result_bytes": IntegerDatabaseField(name="result_bytes"),
+    "memory_usage": IntegerDatabaseField(name="memory_usage"),
+    "status": StringDatabaseField(name="type"),
+    "kind": StringDatabaseField(name="kind"),
+    "query_type": StringDatabaseField(name="query_type"),
+    "is_personal_api_key_request": BooleanDatabaseField(name="is_personal_api_key_request"),
+}
+
+RAW_QUERY_LOG_FIELDS: dict[str, FieldOrTable] = QUERY_LOG_FIELDS | {
+    # below fields are necessary to compute some of the resulting fields
+    "type": StringDatabaseField(name="type"),
+    "is_initial_query": BooleanDatabaseField(name="is_initial_query"),
+    "log_comment": StringDatabaseField(name="log_comment"),
+}
+
+STRING_FIELDS = {
+    "query_type": ["query_type"],
+    "query_id": ["client_query_id"],
+    "query": ["query", "query"],
+    "kind": ["query", "kind"],
+}
+INT_FIELDS = {"created_by": ["user_id"]}
+
+
+class QueryLogTable(LazyTable):
+    fields: dict[str, FieldOrTable] = QUERY_LOG_FIELDS
+
+    def to_printed_clickhouse(self, context) -> str:
+        return "query_log"
+
+    def to_printed_hogql(self) -> str:
+        return "query_log"
+
+    def lazy_select(self, table_to_add: LazyTableToAdd, context, node) -> Any:
+        requested_fields = table_to_add.fields_accessed
+
+        raw_table_name = "raw_query_log"
+
+        def get_alias(name, chain):
+            if name in STRING_FIELDS:
+                keys = STRING_FIELDS[name]
+                expr = ast.Call(
+                    name="JSONExtractString",
+                    args=[ast.Field(chain=[raw_table_name, "log_comment"])] + [ast.Constant(value=v) for v in keys],
+                )
+                return ast.Alias(alias=name, expr=expr)
+            if name in INT_FIELDS:
+                keys = INT_FIELDS[name]
+                expr = ast.Call(
+                    name="JSONExtractInt",
+                    args=[ast.Field(chain=[raw_table_name, "log_comment"])] + [ast.Constant(value=v) for v in keys],
+                )
+                return ast.Alias(alias=name, expr=expr)
+            if name == "is_personal_api_key_request":
+                cmp_expr = ast.CompareOperation(
+                    op=ast.CompareOperationOp.Eq,
+                    left=ast.Constant(value="personal_api_key"),
+                    right=ast.Call(
+                        name="JSONExtractString",
+                        args=[ast.Field(chain=["log_comment"]), ast.Constant(value="access_method")],
+                    ),
+                )
+                return ast.Alias(alias=name, expr=cmp_expr)
+            return ast.Alias(alias=name, expr=ast.Field(chain=[raw_table_name, *chain]))
+
+        fields: list[ast.Expr] = [get_alias(name, chain) for name, chain in requested_fields.items()]
+
+        return ast.SelectQuery(
+            select=fields,
+            select_from=ast.JoinExpr(table=ast.Field(chain=[raw_table_name])),
+            where=ast.And(
+                exprs=[
+                    ast.CompareOperation(
+                        op=ast.CompareOperationOp.Eq,
+                        left=ast.Constant(value=context.project_id),
+                        right=ast.Call(
+                            name="JSONExtractInt",
+                            args=[ast.Field(chain=["log_comment"]), ast.Constant(value="user_id")],
+                        ),
+                    ),
+                    ast.CompareOperation(
+                        op=ast.CompareOperationOp.In,
+                        left=ast.Field(chain=["type"]),
+                        right=ast.Array(
+                            exprs=[
+                                ast.Constant(value="QueryFinish"),
+                                ast.Constant(value="ExceptionBeforeStart"),
+                                ast.Constant(value="ExceptionWhileProcessing"),
+                            ]
+                        ),
+                    ),
+                    ast.Field(chain=["is_initial_query"]),
+                ]
+            ),
+        )
+
+
+class RawQueryLogTable(FunctionCallTable):
+    fields: dict[str, FieldOrTable] = RAW_QUERY_LOG_FIELDS
+
+    name: str = "raw_query_log"
+
+    def to_printed_clickhouse(self, context) -> str:
+        return "clusterAllReplicas(posthog, system.query_log)"
+
+    def to_printed_hogql(self) -> str:
+        return "query_log"
diff --git a/posthog/hogql/database/schema/test/test_persons.py b/posthog/hogql/database/schema/test/test_persons.py
index e259df691d06e..164ff1be1cc5f 100644
--- a/posthog/hogql/database/schema/test/test_persons.py
+++ b/posthog/hogql/database/schema/test/test_persons.py
@@ -5,7 +5,7 @@
     TrendsQuery,
     ActorsQuery,
     EventsNode,
-    InsightDateRange,
+    DateRange,
 )
 from posthog.hogql_queries.actors_query_runner import ActorsQueryRunner
 from posthog.hogql.modifiers import create_default_modifiers_for_team
@@ -102,7 +102,7 @@ def test_joins_are_left_alone_for_now(self):
     def test_person_modal_not_optimized_yet(self):
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="2024-01-01", date_to="2024-01-07"),
+            dateRange=DateRange(date_from="2024-01-01", date_to="2024-01-07"),
             # breakdownFilter=BreakdownFilter(breakdown="$", breakdown_type=BreakdownType.PERSON),
         )
         insight_actors_query = InsightActorsQuery(
diff --git a/posthog/hogql/database/schema/test/test_table_query_log.py b/posthog/hogql/database/schema/test/test_table_query_log.py
new file mode 100644
index 0000000000000..d892520f31ca0
--- /dev/null
+++ b/posthog/hogql/database/schema/test/test_table_query_log.py
@@ -0,0 +1,53 @@
+from unittest.mock import MagicMock, patch
+from posthog.clickhouse.client import sync_execute
+from posthog.hogql.context import HogQLContext
+from posthog.hogql.database.database import create_hogql_database
+from posthog.hogql.query import execute_hogql_query
+from posthog.test.base import (
+    APIBaseTest,
+    ClickhouseTestMixin,
+)
+
+
+class TestPersonOptimization(ClickhouseTestMixin, APIBaseTest):
+    """
+    Mostly tests for the optimization of pre-filtering before aggregating. See https://github.com/PostHog/posthog/pull/25604
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.database = create_hogql_database(self.team.pk)
+        self.context = HogQLContext(database=self.database, team_id=self.team.pk, enable_select_queries=True)
+
+    @patch("posthog.hogql.query.sync_execute", wraps=sync_execute)
+    def test_dumb_query(self, mock_sync_execute: MagicMock):
+        response = execute_hogql_query("select query_start_time from query_log limit 10", self.team)
+
+        ch_query = f"""SELECT
+    query_log.query_start_time AS query_start_time
+FROM
+    (SELECT
+        toTimeZone(raw_query_log.event_time, %(hogql_val_0)s) AS query_start_time
+    FROM
+        clusterAllReplicas(posthog, system.query_log) AS raw_query_log
+    WHERE
+        and(ifNull(equals({self.team.pk}, JSONExtractInt(raw_query_log.log_comment, %(hogql_val_1)s)), 0), in(raw_query_log.type, [%(hogql_val_2)s, %(hogql_val_3)s, %(hogql_val_4)s]), raw_query_log.is_initial_query)) AS query_log
+LIMIT 10 SETTINGS readonly=2, max_execution_time=60, allow_experimental_object_type=1, format_csv_allow_double_quotes=0, max_ast_elements=4000000, max_expanded_ast_elements=4000000, max_bytes_before_external_group_by=0"""
+
+        from unittest.mock import ANY
+
+        mock_sync_execute.assert_called_once_with(
+            ch_query,
+            {
+                "hogql_val_0": "UTC",
+                "hogql_val_1": "user_id",
+                "hogql_val_2": "QueryFinish",
+                "hogql_val_3": "ExceptionBeforeStart",
+                "hogql_val_4": "ExceptionWhileProcessing",
+            },
+            with_column_types=True,
+            workload=ANY,
+            team_id=self.team.pk,
+            readonly=True,
+        )
+        assert response.results is not None
diff --git a/posthog/hogql/database/schema/util/test/test_person_where_clause_extractor.py b/posthog/hogql/database/schema/util/test/test_person_where_clause_extractor.py
index 73459b375879e..3b281c17dd817 100644
--- a/posthog/hogql/database/schema/util/test/test_person_where_clause_extractor.py
+++ b/posthog/hogql/database/schema/util/test/test_person_where_clause_extractor.py
@@ -59,12 +59,13 @@ def get_clause(self, query: str):
         assert isinstance(new_select.select_from, ast.JoinExpr)
         assert isinstance(new_select.select_from.next_join, ast.JoinExpr)
         assert isinstance(new_select.select_from.next_join.next_join, ast.JoinExpr)
-        assert isinstance(new_select.select_from.next_join.next_join.table, ast.SelectQuery)
+        assert isinstance(new_select.select_from.next_join.next_join.next_join, ast.JoinExpr)
+        assert isinstance(new_select.select_from.next_join.next_join.next_join.table, ast.SelectQuery)
 
-        assert new_select.select_from.next_join.alias == "events__pdi"
-        assert new_select.select_from.next_join.next_join.alias == "events__pdi__person"
+        assert new_select.select_from.next_join.next_join.alias == "events__pdi"
+        assert new_select.select_from.next_join.next_join.next_join.alias == "events__pdi__person"
 
-        where = new_select.select_from.next_join.next_join.table.where
+        where = new_select.select_from.next_join.next_join.next_join.table.where
         if where is None:
             return None
 
@@ -194,6 +195,6 @@ def test_boolean(self):
         )
         actual = self.print_query("SELECT * FROM events WHERE person.properties.person_boolean = false")
         assert (
-            f"ifNull(equals(transform(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties"
+            f"ifNull(equals(toBool(transform(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties"
             in actual
         )
diff --git a/posthog/hogql/database/test/__snapshots__/test_database.ambr b/posthog/hogql/database/test/__snapshots__/test_database.ambr
index e3939d569468f..d5d1d67d7c8b5 100644
--- a/posthog/hogql/database/test/__snapshots__/test_database.ambr
+++ b/posthog/hogql/database/test/__snapshots__/test_database.ambr
@@ -478,6 +478,40 @@
                   "schema_valid": true,
                   "table": "person_distinct_id_overrides",
                   "type": "lazy_table"
+              },
+              "event_issue_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "event_issue_id",
+                  "id": null,
+                  "name": "event_issue_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "expression"
+              },
+              "exception_issue_override": {
+                  "chain": null,
+                  "fields": [
+                      "team_id",
+                      "fingerprint",
+                      "issue_id"
+                  ],
+                  "hogql_value": "exception_issue_override",
+                  "id": "exception_issue_override",
+                  "name": "exception_issue_override",
+                  "schema_valid": true,
+                  "table": "error_tracking_issue_fingerprint_overrides",
+                  "type": "lazy_table"
+              },
+              "issue_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "issue_id",
+                  "id": null,
+                  "name": "issue_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "expression"
               }
           },
           "id": "events",
@@ -848,7 +882,10 @@
                       "elements_chain_ids",
                       "elements_chain_elements",
                       "event_person_id",
-                      "override"
+                      "override",
+                      "event_issue_id",
+                      "exception_issue_override",
+                      "issue_id"
                   ],
                   "hogql_value": "events",
                   "id": "events",
@@ -1157,6 +1194,83 @@
           "name": "log_entries",
           "type": "posthog"
       },
+      "app_metrics": {
+          "fields": {
+              "app_source": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "app_source",
+                  "id": null,
+                  "name": "app_source",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "app_source_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "app_source_id",
+                  "id": null,
+                  "name": "app_source_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "instance_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "instance_id",
+                  "id": null,
+                  "name": "instance_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "timestamp": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "timestamp",
+                  "id": null,
+                  "name": "timestamp",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "datetime"
+              },
+              "metric_name": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "metric_name",
+                  "id": null,
+                  "name": "metric_name",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "metric_kind": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "metric_kind",
+                  "id": null,
+                  "name": "metric_kind",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "count": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "count",
+                  "id": null,
+                  "name": "count",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              }
+          },
+          "id": "app_metrics",
+          "name": "app_metrics",
+          "type": "posthog"
+      },
       "sessions": {
           "fields": {
               "id": {
@@ -1590,6 +1704,153 @@
           "id": "heatmaps",
           "name": "heatmaps",
           "type": "posthog"
+      },
+      "query_log": {
+          "fields": {
+              "query_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_id",
+                  "id": null,
+                  "name": "query_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "query": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query",
+                  "id": null,
+                  "name": "query",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "query_start_time": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_start_time",
+                  "id": null,
+                  "name": "query_start_time",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "datetime"
+              },
+              "query_duration_ms": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_duration_ms",
+                  "id": null,
+                  "name": "query_duration_ms",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "float"
+              },
+              "created_by": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "created_by",
+                  "id": null,
+                  "name": "created_by",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "read_rows": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "read_rows",
+                  "id": null,
+                  "name": "read_rows",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "read_bytes": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "read_bytes",
+                  "id": null,
+                  "name": "read_bytes",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "result_rows": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "result_rows",
+                  "id": null,
+                  "name": "result_rows",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "result_bytes": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "result_bytes",
+                  "id": null,
+                  "name": "result_bytes",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "memory_usage": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "memory_usage",
+                  "id": null,
+                  "name": "memory_usage",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "status": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "status",
+                  "id": null,
+                  "name": "status",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "kind": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "kind",
+                  "id": null,
+                  "name": "kind",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "query_type": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_type",
+                  "id": null,
+                  "name": "query_type",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "is_personal_api_key_request": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "is_personal_api_key_request",
+                  "id": null,
+                  "name": "is_personal_api_key_request",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "boolean"
+              }
+          },
+          "id": "query_log",
+          "name": "query_log",
+          "type": "posthog"
       }
   }
   '''
@@ -2028,6 +2289,40 @@
                   "schema_valid": true,
                   "table": null,
                   "type": "array"
+              },
+              "event_issue_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "event_issue_id",
+                  "id": null,
+                  "name": "event_issue_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "expression"
+              },
+              "exception_issue_override": {
+                  "chain": null,
+                  "fields": [
+                      "team_id",
+                      "fingerprint",
+                      "issue_id"
+                  ],
+                  "hogql_value": "exception_issue_override",
+                  "id": "exception_issue_override",
+                  "name": "exception_issue_override",
+                  "schema_valid": true,
+                  "table": "error_tracking_issue_fingerprint_overrides",
+                  "type": "lazy_table"
+              },
+              "issue_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "issue_id",
+                  "id": null,
+                  "name": "issue_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "expression"
               }
           },
           "id": "events",
@@ -2396,7 +2691,10 @@
                       "elements_chain_href",
                       "elements_chain_texts",
                       "elements_chain_ids",
-                      "elements_chain_elements"
+                      "elements_chain_elements",
+                      "event_issue_id",
+                      "exception_issue_override",
+                      "issue_id"
                   ],
                   "hogql_value": "events",
                   "id": "events",
@@ -2705,6 +3003,83 @@
           "name": "log_entries",
           "type": "posthog"
       },
+      "app_metrics": {
+          "fields": {
+              "app_source": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "app_source",
+                  "id": null,
+                  "name": "app_source",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "app_source_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "app_source_id",
+                  "id": null,
+                  "name": "app_source_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "instance_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "instance_id",
+                  "id": null,
+                  "name": "instance_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "timestamp": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "timestamp",
+                  "id": null,
+                  "name": "timestamp",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "datetime"
+              },
+              "metric_name": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "metric_name",
+                  "id": null,
+                  "name": "metric_name",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "metric_kind": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "metric_kind",
+                  "id": null,
+                  "name": "metric_kind",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "count": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "count",
+                  "id": null,
+                  "name": "count",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              }
+          },
+          "id": "app_metrics",
+          "name": "app_metrics",
+          "type": "posthog"
+      },
       "sessions": {
           "fields": {
               "id": {
@@ -3138,6 +3513,153 @@
           "id": "heatmaps",
           "name": "heatmaps",
           "type": "posthog"
+      },
+      "query_log": {
+          "fields": {
+              "query_id": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_id",
+                  "id": null,
+                  "name": "query_id",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "query": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query",
+                  "id": null,
+                  "name": "query",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "query_start_time": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_start_time",
+                  "id": null,
+                  "name": "query_start_time",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "datetime"
+              },
+              "query_duration_ms": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_duration_ms",
+                  "id": null,
+                  "name": "query_duration_ms",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "float"
+              },
+              "created_by": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "created_by",
+                  "id": null,
+                  "name": "created_by",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "read_rows": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "read_rows",
+                  "id": null,
+                  "name": "read_rows",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "read_bytes": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "read_bytes",
+                  "id": null,
+                  "name": "read_bytes",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "result_rows": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "result_rows",
+                  "id": null,
+                  "name": "result_rows",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "result_bytes": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "result_bytes",
+                  "id": null,
+                  "name": "result_bytes",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "memory_usage": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "memory_usage",
+                  "id": null,
+                  "name": "memory_usage",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "integer"
+              },
+              "status": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "status",
+                  "id": null,
+                  "name": "status",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "kind": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "kind",
+                  "id": null,
+                  "name": "kind",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "query_type": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "query_type",
+                  "id": null,
+                  "name": "query_type",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "string"
+              },
+              "is_personal_api_key_request": {
+                  "chain": null,
+                  "fields": null,
+                  "hogql_value": "is_personal_api_key_request",
+                  "id": null,
+                  "name": "is_personal_api_key_request",
+                  "schema_valid": true,
+                  "table": null,
+                  "type": "boolean"
+              }
+          },
+          "id": "query_log",
+          "name": "query_log",
+          "type": "posthog"
       }
   }
   '''
diff --git a/posthog/hogql/functions/action.py b/posthog/hogql/functions/action.py
index 5ed8a156e393b..d1f7fe85223d8 100644
--- a/posthog/hogql/functions/action.py
+++ b/posthog/hogql/functions/action.py
@@ -15,7 +15,7 @@ def matches_action(node: ast.Expr, args: list[ast.Expr], context: HogQLContext)
     from posthog.hogql.property import action_to_expr
 
     if (isinstance(arg.value, int) or isinstance(arg.value, float)) and not isinstance(arg.value, bool):
-        actions = Action.objects.filter(id=int(arg.value), team_id=context.team_id).all()
+        actions = Action.objects.filter(id=int(arg.value), team__project_id=context.project_id).all()
         if len(actions) == 1:
             context.add_notice(
                 start=arg.start,
@@ -27,7 +27,7 @@ def matches_action(node: ast.Expr, args: list[ast.Expr], context: HogQLContext)
         raise QueryError(f"Could not find cohort with ID {arg.value}", node=arg)
 
     if isinstance(arg.value, str):
-        actions = Action.objects.filter(name=arg.value, team_id=context.team_id).all()
+        actions = Action.objects.filter(name=arg.value, team__project_id=context.project_id).all()
         if len(actions) == 1:
             context.add_notice(
                 start=arg.start,
diff --git a/posthog/hogql/functions/cohort.py b/posthog/hogql/functions/cohort.py
index 2b0992c6e7ef9..bb01604fddcde 100644
--- a/posthog/hogql/functions/cohort.py
+++ b/posthog/hogql/functions/cohort.py
@@ -31,7 +31,7 @@ def cohort(node: ast.Expr, args: list[ast.Expr], context: HogQLContext) -> ast.E
     from posthog.models import Cohort
 
     if (isinstance(arg.value, int) or isinstance(arg.value, float)) and not isinstance(arg.value, bool):
-        cohorts1 = Cohort.objects.filter(id=int(arg.value), team_id=context.team_id).values_list(
+        cohorts1 = Cohort.objects.filter(id=int(arg.value), team__project_id=context.project_id).values_list(
             "id", "is_static", "version", "name"
         )
         if len(cohorts1) == 1:
@@ -45,7 +45,7 @@ def cohort(node: ast.Expr, args: list[ast.Expr], context: HogQLContext) -> ast.E
         raise QueryError(f"Could not find cohort with ID {arg.value}", node=arg)
 
     if isinstance(arg.value, str):
-        cohorts2 = Cohort.objects.filter(name=arg.value, team_id=context.team_id).values_list(
+        cohorts2 = Cohort.objects.filter(name=arg.value, team__project_id=context.project_id).values_list(
             "id", "is_static", "version"
         )
         if len(cohorts2) == 1:
diff --git a/posthog/hogql/functions/mapping.py b/posthog/hogql/functions/mapping.py
index d0f4755c67bad..43c9bb4e7c150 100644
--- a/posthog/hogql/functions/mapping.py
+++ b/posthog/hogql/functions/mapping.py
@@ -398,7 +398,7 @@ def compare_types(arg_types: list[ConstantType], sig_arg_types: tuple[ConstantTy
     "_toUInt64": HogQLFunctionMeta("toUInt64", 1, 1, signatures=[((UnknownType(),), IntegerType())]),
     "_toUInt128": HogQLFunctionMeta("toUInt128", 1, 1),
     "toFloat": HogQLFunctionMeta("accurateCastOrNull", 1, 1, suffix_args=[ast.Constant(value="Float64")]),
-    "toDecimal": HogQLFunctionMeta("accurateCastOrNull", 1, 1, suffix_args=[ast.Constant(value="Decimal64")]),
+    "toDecimal": HogQLFunctionMeta("toDecimal64OrNull", 2, 2),
     "toDate": HogQLFunctionMeta(
         "toDateOrNull",
         1,
@@ -432,6 +432,7 @@ def compare_types(arg_types: list[ConstantType], sig_arg_types: tuple[ConstantTy
             ((DateTimeType(), StringType()), StringType()),
         ],
     ),
+    "toBool": HogQLFunctionMeta("toBool", 1, 1),
     "toJSONString": HogQLFunctionMeta("toJSONString", 1, 1),
     "parseDateTime": HogQLFunctionMeta("parseDateTimeOrNull", 2, 3, tz_aware=True),
     "parseDateTimeBestEffort": HogQLFunctionMeta("parseDateTime64BestEffortOrNull", 1, 2, tz_aware=True),
diff --git a/posthog/hogql/functions/test/__snapshots__/test_cohort.ambr b/posthog/hogql/functions/test/__snapshots__/test_cohort.ambr
index 3b0f781470789..e3f18c55f6c2e 100644
--- a/posthog/hogql/functions/test/__snapshots__/test_cohort.ambr
+++ b/posthog/hogql/functions/test/__snapshots__/test_cohort.ambr
@@ -27,6 +27,34 @@
   LIMIT 100
   '''
 # ---
+# name: TestCohort.test_in_cohort_dynamic_other_team_in_project
+  '''
+  -- ClickHouse
+  
+  SELECT events.event AS event 
+  FROM events 
+  WHERE and(equals(events.team_id, 99999), in(events.person_id, (
+  SELECT cohortpeople.person_id AS person_id 
+  FROM cohortpeople 
+  WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, XX)) 
+  GROUP BY cohortpeople.person_id, cohortpeople.cohort_id, cohortpeople.version 
+  HAVING ifNull(greater(sum(cohortpeople.sign), 0), 0))), equals(events.event, %(hogql_val_0)s)) 
+  LIMIT 100 
+  SETTINGS readonly=2, max_execution_time=60, allow_experimental_object_type=1, format_csv_allow_double_quotes=0, max_ast_elements=4000000, max_expanded_ast_elements=4000000, max_bytes_before_external_group_by=0
+  
+  -- HogQL
+  
+  SELECT event 
+  FROM events 
+  WHERE and(in(person_id, (
+  SELECT person_id 
+  FROM raw_cohort_people 
+  WHERE equals(cohort_id, XX) 
+  GROUP BY person_id, cohort_id, version 
+  HAVING greater(sum(sign), 0))), equals(event, 'RANDOM_TEST_ID::UUID')) 
+  LIMIT 100
+  '''
+# ---
 # name: TestCohort.test_in_cohort_static
   '''
   -- ClickHouse
diff --git a/posthog/hogql/functions/test/test_cohort.py b/posthog/hogql/functions/test/test_cohort.py
index 4ea1830a417b1..dbedef9739fd4 100644
--- a/posthog/hogql/functions/test/test_cohort.py
+++ b/posthog/hogql/functions/test/test_cohort.py
@@ -8,6 +8,7 @@
 from posthog.hogql.test.utils import pretty_print_response_in_tests
 from posthog.models import Cohort
 from posthog.models.cohort.util import recalculate_cohortpeople
+from posthog.models.team.team import Team
 from posthog.models.utils import UUIDT
 from posthog.schema import HogQLQueryModifiers
 from posthog.test.base import (
@@ -51,7 +52,27 @@ def test_in_cohort_dynamic(self):
             modifiers=HogQLQueryModifiers(inCohortVia="subquery"),
             pretty=False,
         )
-        assert pretty_print_response_in_tests(response, self.team.pk) == self.snapshot
+        assert pretty_print_response_in_tests(response, self.team.pk) == self.snapshot  # type: ignore
+        self.assertEqual(len(response.results), 1)
+        self.assertEqual(response.results[0][0], random_uuid)
+
+    @pytest.mark.usefixtures("unittest_snapshot")
+    @override_settings(PERSON_ON_EVENTS_OVERRIDE=True, PERSON_ON_EVENTS_V2_OVERRIDE=False)
+    def test_in_cohort_dynamic_other_team_in_project(self):
+        random_uuid = self._create_random_events()
+        other_team_in_project = Team.objects.create(organization=self.organization, project=self.project)
+        cohort = Cohort.objects.create(
+            team=other_team_in_project,  # Not self.team!
+            groups=[{"properties": [{"key": "$os", "value": "Chrome", "type": "person"}]}],
+        )
+        recalculate_cohortpeople(cohort, pending_version=0, initiating_user_id=None)
+        response = execute_hogql_query(
+            f"SELECT event FROM events WHERE person_id IN COHORT {cohort.pk} AND event='{random_uuid}'",
+            self.team,
+            modifiers=HogQLQueryModifiers(inCohortVia="subquery"),
+            pretty=False,
+        )
+        assert pretty_print_response_in_tests(response, self.team.pk) == self.snapshot  # type: ignore
         self.assertEqual(len(response.results), 1)
         self.assertEqual(response.results[0][0], random_uuid)
 
@@ -68,7 +89,7 @@ def test_in_cohort_static(self):
             modifiers=HogQLQueryModifiers(inCohortVia="subquery"),
             pretty=False,
         )
-        assert pretty_print_response_in_tests(response, self.team.pk) == self.snapshot
+        assert pretty_print_response_in_tests(response, self.team.pk) == self.snapshot  # type: ignore
 
     @pytest.mark.usefixtures("unittest_snapshot")
     @override_settings(PERSON_ON_EVENTS_OVERRIDE=True, PERSON_ON_EVENTS_V2_OVERRIDE=False)
@@ -84,7 +105,7 @@ def test_in_cohort_strings(self):
             modifiers=HogQLQueryModifiers(inCohortVia="subquery"),
             pretty=False,
         )
-        assert pretty_print_response_in_tests(response, self.team.pk) == self.snapshot
+        assert pretty_print_response_in_tests(response, self.team.pk) == self.snapshot  # type: ignore
 
     @override_settings(PERSON_ON_EVENTS_OVERRIDE=True, PERSON_ON_EVENTS_V2_OVERRIDE=True)
     def test_in_cohort_error(self):
diff --git a/posthog/hogql/metadata.py b/posthog/hogql/metadata.py
index de309adf441b7..ea82d78a0f0ba 100644
--- a/posthog/hogql/metadata.py
+++ b/posthog/hogql/metadata.py
@@ -26,6 +26,7 @@
     HogQLMetadataResponse,
     HogQLNotice,
 )
+from posthog.hogql.visitor import TraversingVisitor
 
 
 def get_hogql_metadata(
@@ -39,6 +40,7 @@ def get_hogql_metadata(
         errors=[],
         warnings=[],
         notices=[],
+        table_names=[],
     )
 
     query_modifiers = create_default_modifiers_for_team(team)
@@ -71,6 +73,8 @@ def get_hogql_metadata(
             if query.variables:
                 select_ast = replace_variables(select_ast, list(query.variables.values()), team)
             _is_valid_view = is_valid_view(select_ast)
+            table_names = get_table_names(select_ast)
+            response.table_names = table_names
             response.isValidView = _is_valid_view
             print_ast(
                 select_ast,
@@ -138,3 +142,28 @@ def is_valid_view(select_query: ast.SelectQuery | ast.SelectSetQuery) -> bool:
                 if field.chain and field.chain[-1] == "*":
                     return False
     return True
+
+
+def get_table_names(select_query: ast.SelectQuery | ast.SelectSetQuery) -> list[str]:
+    # Don't need types, we're only interested in the table names as passed in
+    collector = TableCollector()
+    collector.visit(select_query)
+    return list(collector.table_names - collector.ctes)
+
+
+class TableCollector(TraversingVisitor):
+    def __init__(self):
+        self.table_names = set()
+        self.ctes = set()
+
+    def visit_cte(self, node: ast.CTE):
+        self.ctes.add(node.name)
+        super().visit(node.expr)
+
+    def visit_join_expr(self, node: ast.JoinExpr):
+        if isinstance(node.table, ast.Field):
+            self.table_names.add(node.table.chain[0])
+        else:
+            self.visit(node.table)
+
+        self.visit(node.next_join)
diff --git a/posthog/hogql/printer.py b/posthog/hogql/printer.py
index 37fea932f2014..27a4d85a84c66 100644
--- a/posthog/hogql/printer.py
+++ b/posthog/hogql/printer.py
@@ -6,7 +6,11 @@
 from typing import Literal, Optional, Union, cast
 from uuid import UUID
 
-from posthog.clickhouse.materialized_columns import TablesWithMaterializedColumns, get_enabled_materialized_columns
+from posthog.clickhouse.materialized_columns import (
+    MaterializedColumn,
+    TablesWithMaterializedColumns,
+    get_materialized_column_for_property,
+)
 from posthog.clickhouse.property_groups import property_groups
 from posthog.hogql import ast
 from posthog.hogql.base import AST, _T_AST
@@ -14,6 +18,7 @@
     MAX_SELECT_RETURNED_ROWS,
     HogQLGlobalSettings,
 )
+from posthog.hogql.database.schema.query_log import RawQueryLogTable
 from posthog.hogql.functions import (
     ADD_OR_NULL_DATETIME_FUNCTIONS,
     FIRST_ARG_DATETIME_FUNCTIONS,
@@ -197,6 +202,7 @@ class JoinExprResponse:
 class PrintableMaterializedColumn:
     table: Optional[str]
     column: str
+    is_nullable: bool
 
     def __str__(self) -> str:
         if self.table is None:
@@ -489,7 +495,9 @@ def visit_join_expr(self, node: ast.JoinExpr) -> JoinExprResponse:
             else:
                 sql = table_type.table.to_printed_hogql()
 
-            if isinstance(table_type.table, FunctionCallTable) and not isinstance(table_type.table, S3Table):
+            if isinstance(table_type.table, FunctionCallTable) and not (
+                isinstance(table_type.table, S3Table) or isinstance(table_type.table, RawQueryLogTable)
+            ):
                 if node.table_args is None:
                     raise QueryError(f"Table function '{table_type.table.name}' requires arguments")
 
@@ -1152,7 +1160,7 @@ def visit_call(self, node: ast.Call):
                 args_part = f"({', '.join(args)})"
                 return f"{relevant_clickhouse_name}{params_part}{args_part}"
             else:
-                return f"{node.name}({', '.join([self.visit(arg) for arg in node.args ])})"
+                return f"{node.name}({', '.join([self.visit(arg) for arg in node.args])})"
         elif func_meta := find_hogql_posthog_function(node.name):
             validate_function_args(node.args, func_meta.min_args, func_meta.max_args, node.name)
             args = [self.visit(arg) for arg in node.args]
@@ -1321,10 +1329,11 @@ def __get_all_materialized_property_sources(
             field_name = cast(Union[Literal["properties"], Literal["person_properties"]], field.name)
 
             materialized_column = self._get_materialized_column(table_name, property_name, field_name)
-            if materialized_column:
+            if materialized_column is not None:
                 yield PrintableMaterializedColumn(
                     self.visit(field_type.table_type),
-                    self._print_identifier(materialized_column),
+                    self._print_identifier(materialized_column.name),
+                    is_nullable=materialized_column.is_nullable,
                 )
 
             if self.context.modifiers.propertyGroupsMode in (
@@ -1352,8 +1361,12 @@ def __get_all_materialized_property_sources(
                 materialized_column = self._get_materialized_column("events", property_name, "person_properties")
             else:
                 materialized_column = self._get_materialized_column("person", property_name, "properties")
-            if materialized_column:
-                yield PrintableMaterializedColumn(None, self._print_identifier(materialized_column))
+            if materialized_column is not None:
+                yield PrintableMaterializedColumn(
+                    None,
+                    self._print_identifier(materialized_column.name),
+                    is_nullable=materialized_column.is_nullable,
+                )
 
     def visit_property_type(self, type: ast.PropertyType):
         if type.joined_subquery is not None and type.joined_subquery_field_name is not None:
@@ -1361,7 +1374,10 @@ def visit_property_type(self, type: ast.PropertyType):
 
         materialized_property_source = self.__get_materialized_property_source_for_property_type(type)
         if materialized_property_source is not None:
-            if isinstance(materialized_property_source, PrintableMaterializedColumn):
+            if (
+                isinstance(materialized_property_source, PrintableMaterializedColumn)
+                and not materialized_property_source.is_nullable
+            ):
                 # TODO: rematerialize all columns to properly support empty strings and "null" string values.
                 if self.context.modifiers.materializationMode == MaterializationMode.LEGACY_NULL_AS_STRING:
                     materialized_property_sql = f"nullIf({materialized_property_source}, '')"
@@ -1511,9 +1527,10 @@ def _unsafe_json_extract_trim_quotes(self, unsafe_field: str, unsafe_args: list[
 
     def _get_materialized_column(
         self, table_name: str, property_name: PropertyName, field_name: TableColumn
-    ) -> Optional[str]:
-        materialized_columns = get_enabled_materialized_columns(cast(TablesWithMaterializedColumns, table_name))
-        return materialized_columns.get((property_name, field_name), None)
+    ) -> MaterializedColumn | None:
+        return get_materialized_column_for_property(
+            cast(TablesWithMaterializedColumns, table_name), field_name, property_name
+        )
 
     def _get_timezone(self) -> str:
         return self.context.database.get_timezone() if self.context.database else "UTC"
diff --git a/posthog/hogql/property.py b/posthog/hogql/property.py
index e372b446b5c91..01421937ea52d 100644
--- a/posthog/hogql/property.py
+++ b/posthog/hogql/property.py
@@ -506,7 +506,7 @@ def property_to_expr(
     elif property.type == "cohort" or property.type == "static-cohort" or property.type == "precalculated-cohort":
         if not team:
             raise Exception("Can not convert cohort property to expression without team")
-        cohort = Cohort.objects.get(team=team, id=property.value)
+        cohort = Cohort.objects.get(team__project_id=team.project_id, id=property.value)
         return ast.CompareOperation(
             left=ast.Field(chain=["id" if scope == "person" else "person_id"]),
             op=ast.CompareOperationOp.NotInCohort
diff --git a/posthog/hogql/test/__snapshots__/test_resolver.ambr b/posthog/hogql/test/__snapshots__/test_resolver.ambr
index cfc878e6004b8..a9f25124489a2 100644
--- a/posthog/hogql/test/__snapshots__/test_resolver.ambr
+++ b/posthog/hogql/test/__snapshots__/test_resolver.ambr
@@ -37,7 +37,9 @@
                           elements_chain_ids: {},
                           elements_chain_texts: {},
                           event: {},
+                          event_issue_id: {},
                           event_person_id: {},
+                          exception_issue_override: {},
                           goe_0: {},
                           goe_1: {},
                           goe_2: {},
@@ -48,6 +50,7 @@
                           group_2: {},
                           group_3: {},
                           group_4: {},
+                          issue_id: {},
                           override: {},
                           pdi: {},
                           person: {},
@@ -161,6 +164,22 @@
                     table_type: <recursion ...>
                   }
                 },
+                event_issue_id: {
+                  alias: "event_issue_id"
+                  type: {
+                    arg_types: [
+                      {
+                        data_type: "str"
+                        nullable: False
+                      }
+                    ]
+                    name: "toUUID"
+                    return_type: {
+                      data_type: "unknown"
+                      nullable: True
+                    }
+                  }
+                },
                 event_person_id: {
                   alias: "event_person_id"
                   type: {
@@ -168,6 +187,30 @@
                     table_type: <recursion ...>
                   }
                 },
+                issue_id: {
+                  alias: "issue_id"
+                  type: {
+                    arg_types: [
+                      {
+                        data_type: "unknown"
+                        nullable: True
+                      },
+                      {
+                        data_type: "str"
+                        nullable: False
+                      },
+                      {
+                        data_type: "unknown"
+                        nullable: True
+                      }
+                    ]
+                    name: "if"
+                    return_type: {
+                      data_type: "unknown"
+                      nullable: True
+                    }
+                  }
+                },
                 person_id: {
                   alias: "person_id"
                   type: {
@@ -549,6 +592,40 @@
           alias: "event_person_id"
           type: <recursion ...>
         }
+      },
+      {
+        alias: "event_issue_id"
+        expr: {
+          chain: [
+            "event_issue_id"
+          ]
+          type: {
+            name: "event_issue_id"
+            table_type: <recursion ...>
+          }
+        }
+        hidden: True
+        type: {
+          alias: "event_issue_id"
+          type: <recursion ...>
+        }
+      },
+      {
+        alias: "issue_id"
+        expr: {
+          chain: [
+            "issue_id"
+          ]
+          type: {
+            name: "issue_id"
+            table_type: <recursion ...>
+          }
+        }
+        hidden: True
+        type: {
+          alias: "issue_id"
+          type: <recursion ...>
+        }
       }
     ]
     select_from: {
@@ -895,6 +972,210 @@
             }
             hidden: True
             type: <recursion ...>
+          },
+          {
+            alias: "event_issue_id"
+            expr: {
+              args: [
+                {
+                  alias: "$exception_issue_id"
+                  expr: {
+                    chain: [
+                      "properties",
+                      "$exception_issue_id"
+                    ]
+                    end: 37
+                    start: 7
+                    type: {
+                      chain: [
+                        "$exception_issue_id"
+                      ]
+                      field_type: {
+                        name: "properties"
+                        table_type: <recursion ...>
+                      }
+                    }
+                  }
+                  hidden: True
+                  type: {
+                    alias: "$exception_issue_id"
+                    type: <recursion ...>
+                  }
+                }
+              ]
+              distinct: False
+              end: 38
+              name: "toUUID"
+              start: 0
+              type: <recursion ...>
+            }
+            hidden: True
+            type: <recursion ...>
+          },
+          {
+            alias: "issue_id"
+            expr: {
+              args: [
+                {
+                  args: [
+                    {
+                      args: [
+                        {
+                          alias: "issue_id"
+                          expr: {
+                            chain: [
+                              "exception_issue_override",
+                              "issue_id"
+                            ]
+                            type: {
+                              name: "issue_id"
+                              table_type: {
+                                field: "exception_issue_override"
+                                lazy_join: {
+                                  from_field: [
+                                    "fingerprint"
+                                  ],
+                                  join_function: <function>,
+                                  join_table: {
+                                    fields: {
+                                      fingerprint: {},
+                                      issue_id: {},
+                                      team_id: {}
+                                    }
+                                  },
+                                  to_field: None
+                                }
+                                table_type: <recursion ...>
+                              }
+                            }
+                          }
+                          hidden: True
+                          type: {
+                            alias: "issue_id"
+                            type: <recursion ...>
+                          }
+                        }
+                      ]
+                      distinct: False
+                      name: "empty"
+                      type: {
+                        arg_types: [
+                          {
+                            data_type: "str"
+                            nullable: False
+                          }
+                        ]
+                        name: "empty"
+                        return_type: {
+                          data_type: "unknown"
+                          nullable: True
+                        }
+                      }
+                    }
+                  ]
+                  distinct: False
+                  name: "not"
+                  type: {
+                    arg_types: [
+                      <recursion ...>
+                    ]
+                    name: "not"
+                    return_type: <recursion ...>
+                  }
+                },
+                {
+                  alias: "issue_id"
+                  expr: {
+                    chain: [
+                      "exception_issue_override",
+                      "issue_id"
+                    ]
+                    type: {
+                      name: "issue_id"
+                      table_type: {
+                        field: "exception_issue_override"
+                        lazy_join: {
+                          from_field: [
+                            "fingerprint"
+                          ],
+                          join_function: <function>,
+                          join_table: {
+                            fields: {
+                              fingerprint: {},
+                              issue_id: {},
+                              team_id: {}
+                            }
+                          },
+                          to_field: None
+                        }
+                        table_type: <recursion ...>
+                      }
+                    }
+                  }
+                  hidden: True
+                  type: {
+                    alias: "issue_id"
+                    type: <recursion ...>
+                  }
+                },
+                {
+                  alias: "event_issue_id"
+                  expr: {
+                    args: [
+                      {
+                        alias: "$exception_issue_id"
+                        expr: {
+                          chain: [
+                            "properties",
+                            "$exception_issue_id"
+                          ]
+                          end: 37
+                          start: 7
+                          type: {
+                            chain: [
+                              "$exception_issue_id"
+                            ]
+                            field_type: {
+                              name: "properties"
+                              table_type: <recursion ...>
+                            }
+                          }
+                        }
+                        hidden: True
+                        type: {
+                          alias: "$exception_issue_id"
+                          type: <recursion ...>
+                        }
+                      }
+                    ]
+                    distinct: False
+                    end: 38
+                    name: "toUUID"
+                    start: 0
+                    type: {
+                      arg_types: [
+                        {
+                          data_type: "str"
+                          nullable: False
+                        }
+                      ]
+                      name: "toUUID"
+                      return_type: <recursion ...>
+                    }
+                  }
+                  hidden: True
+                  type: {
+                    alias: "event_issue_id"
+                    type: <recursion ...>
+                  }
+                }
+              ]
+              distinct: False
+              name: "if"
+              type: <recursion ...>
+            }
+            hidden: True
+            type: <recursion ...>
           }
         ]
         select_from: {
@@ -931,7 +1212,9 @@
         elements_chain_ids: <recursion ...>,
         elements_chain_texts: <recursion ...>,
         event: <recursion ...>,
+        event_issue_id: <recursion ...>,
         event_person_id: <recursion ...>,
+        issue_id: <recursion ...>,
         person_id: <recursion ...>,
         properties: <recursion ...>,
         timestamp: <recursion ...>,
@@ -973,7 +1256,9 @@
                   elements_chain_ids: {},
                   elements_chain_texts: {},
                   event: {},
+                  event_issue_id: {},
                   event_person_id: {},
+                  exception_issue_override: {},
                   goe_0: {},
                   goe_1: {},
                   goe_2: {},
@@ -985,6 +1270,7 @@
                   group_3: {},
                   group_4: {},
                   hidden_field: {},
+                  issue_id: {},
                   override: {},
                   pdi: {},
                   person: {},
@@ -1467,44 +1753,288 @@
           alias: "event_person_id"
           type: <recursion ...>
         }
-      }
-    ]
-    select_from: {
-      table: {
-        chain: [
-          "events"
-        ]
-        type: <recursion ...>
-      }
-      type: <recursion ...>
-    }
-    type: {
-      aliases: {}
-      anonymous_tables: []
-      columns: {
-        $group_0: <recursion ...>,
-        $group_1: <recursion ...>,
-        $group_2: <recursion ...>,
-        $group_3: <recursion ...>,
-        $group_4: <recursion ...>,
-        $session_id: <recursion ...>,
-        $window_id: <recursion ...>,
-        created_at: <recursion ...>,
-        distinct_id: <recursion ...>,
-        elements_chain: <recursion ...>,
-        elements_chain_elements: <recursion ...>,
-        elements_chain_href: <recursion ...>,
-        elements_chain_ids: <recursion ...>,
-        elements_chain_texts: <recursion ...>,
-        event: <recursion ...>,
-        event_person_id: <recursion ...>,
-        person_id: <recursion ...>,
-        properties: <recursion ...>,
-        timestamp: <recursion ...>,
-        uuid: <recursion ...>
-      }
-      ctes: {}
-      tables: {
+      },
+      {
+        alias: "event_issue_id"
+        expr: {
+          args: [
+            {
+              alias: "$exception_issue_id"
+              expr: {
+                chain: [
+                  "properties",
+                  "$exception_issue_id"
+                ]
+                end: 37
+                start: 7
+                type: {
+                  chain: [
+                    "$exception_issue_id"
+                  ]
+                  field_type: {
+                    name: "properties"
+                    table_type: <recursion ...>
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "$exception_issue_id"
+                type: <recursion ...>
+              }
+            }
+          ]
+          distinct: False
+          end: 38
+          name: "toUUID"
+          start: 0
+          type: {
+            arg_types: [
+              {
+                data_type: "str"
+                nullable: False
+              }
+            ]
+            name: "toUUID"
+            return_type: {
+              data_type: "unknown"
+              nullable: True
+            }
+          }
+        }
+        hidden: True
+        type: {
+          alias: "event_issue_id"
+          type: <recursion ...>
+        }
+      },
+      {
+        alias: "issue_id"
+        expr: {
+          args: [
+            {
+              args: [
+                {
+                  args: [
+                    {
+                      alias: "issue_id"
+                      expr: {
+                        chain: [
+                          "exception_issue_override",
+                          "issue_id"
+                        ]
+                        type: {
+                          name: "issue_id"
+                          table_type: {
+                            field: "exception_issue_override"
+                            lazy_join: {
+                              from_field: [
+                                "fingerprint"
+                              ],
+                              join_function: <function>,
+                              join_table: {
+                                fields: {
+                                  fingerprint: {},
+                                  issue_id: {},
+                                  team_id: {}
+                                }
+                              },
+                              to_field: None
+                            }
+                            table_type: <recursion ...>
+                          }
+                        }
+                      }
+                      hidden: True
+                      type: {
+                        alias: "issue_id"
+                        type: <recursion ...>
+                      }
+                    }
+                  ]
+                  distinct: False
+                  name: "empty"
+                  type: {
+                    arg_types: [
+                      {
+                        data_type: "str"
+                        nullable: False
+                      }
+                    ]
+                    name: "empty"
+                    return_type: {
+                      data_type: "unknown"
+                      nullable: True
+                    }
+                  }
+                }
+              ]
+              distinct: False
+              name: "not"
+              type: {
+                arg_types: [
+                  <recursion ...>
+                ]
+                name: "not"
+                return_type: {
+                  data_type: "unknown"
+                  nullable: True
+                }
+              }
+            },
+            {
+              alias: "issue_id"
+              expr: {
+                chain: [
+                  "exception_issue_override",
+                  "issue_id"
+                ]
+                type: {
+                  name: "issue_id"
+                  table_type: {
+                    field: "exception_issue_override"
+                    lazy_join: {
+                      from_field: [
+                        "fingerprint"
+                      ],
+                      join_function: <function>,
+                      join_table: {
+                        fields: {
+                          fingerprint: {},
+                          issue_id: {},
+                          team_id: {}
+                        }
+                      },
+                      to_field: None
+                    }
+                    table_type: <recursion ...>
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "issue_id"
+                type: <recursion ...>
+              }
+            },
+            {
+              alias: "event_issue_id"
+              expr: {
+                args: [
+                  {
+                    alias: "$exception_issue_id"
+                    expr: {
+                      chain: [
+                        "properties",
+                        "$exception_issue_id"
+                      ]
+                      end: 37
+                      start: 7
+                      type: {
+                        chain: [
+                          "$exception_issue_id"
+                        ]
+                        field_type: {
+                          name: "properties"
+                          table_type: <recursion ...>
+                        }
+                      }
+                    }
+                    hidden: True
+                    type: {
+                      alias: "$exception_issue_id"
+                      type: <recursion ...>
+                    }
+                  }
+                ]
+                distinct: False
+                end: 38
+                name: "toUUID"
+                start: 0
+                type: {
+                  arg_types: [
+                    {
+                      data_type: "str"
+                      nullable: False
+                    }
+                  ]
+                  name: "toUUID"
+                  return_type: {
+                    data_type: "unknown"
+                    nullable: True
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "event_issue_id"
+                type: <recursion ...>
+              }
+            }
+          ]
+          distinct: False
+          name: "if"
+          type: {
+            arg_types: [
+              <recursion ...>,
+              {
+                data_type: "str"
+                nullable: False
+              },
+              <recursion ...>
+            ]
+            name: "if"
+            return_type: {
+              data_type: "unknown"
+              nullable: True
+            }
+          }
+        }
+        hidden: True
+        type: {
+          alias: "issue_id"
+          type: <recursion ...>
+        }
+      }
+    ]
+    select_from: {
+      table: {
+        chain: [
+          "events"
+        ]
+        type: <recursion ...>
+      }
+      type: <recursion ...>
+    }
+    type: {
+      aliases: {}
+      anonymous_tables: []
+      columns: {
+        $group_0: <recursion ...>,
+        $group_1: <recursion ...>,
+        $group_2: <recursion ...>,
+        $group_3: <recursion ...>,
+        $group_4: <recursion ...>,
+        $session_id: <recursion ...>,
+        $window_id: <recursion ...>,
+        created_at: <recursion ...>,
+        distinct_id: <recursion ...>,
+        elements_chain: <recursion ...>,
+        elements_chain_elements: <recursion ...>,
+        elements_chain_href: <recursion ...>,
+        elements_chain_ids: <recursion ...>,
+        elements_chain_texts: <recursion ...>,
+        event: <recursion ...>,
+        event_issue_id: <recursion ...>,
+        event_person_id: <recursion ...>,
+        issue_id: <recursion ...>,
+        person_id: <recursion ...>,
+        properties: <recursion ...>,
+        timestamp: <recursion ...>,
+        uuid: <recursion ...>
+      }
+      ctes: {}
+      tables: {
         events: <recursion ...>
       }
     }
@@ -2224,7 +2754,9 @@
                           elements_chain_ids: {},
                           elements_chain_texts: {},
                           event: {},
+                          event_issue_id: {},
                           event_person_id: {},
+                          exception_issue_override: {},
                           goe_0: {},
                           goe_1: {},
                           goe_2: {},
@@ -2235,6 +2767,7 @@
                           group_2: {},
                           group_3: {},
                           group_4: {},
+                          issue_id: {},
                           override: {},
                           pdi: {},
                           person: {},
@@ -2348,6 +2881,22 @@
                     table_type: <recursion ...>
                   }
                 },
+                event_issue_id: {
+                  alias: "event_issue_id"
+                  type: {
+                    arg_types: [
+                      {
+                        data_type: "str"
+                        nullable: False
+                      }
+                    ]
+                    name: "toUUID"
+                    return_type: {
+                      data_type: "unknown"
+                      nullable: True
+                    }
+                  }
+                },
                 event_person_id: {
                   alias: "event_person_id"
                   type: {
@@ -2355,8 +2904,8 @@
                     table_type: <recursion ...>
                   }
                 },
-                person_id: {
-                  alias: "person_id"
+                issue_id: {
+                  alias: "issue_id"
                   type: {
                     arg_types: [
                       {
@@ -2368,8 +2917,8 @@
                         nullable: False
                       },
                       {
-                        data_type: "str"
-                        nullable: False
+                        data_type: "unknown"
+                        nullable: True
                       }
                     ]
                     name: "if"
@@ -2379,17 +2928,41 @@
                     }
                   }
                 },
-                properties: {
-                  alias: "properties"
-                  type: {
-                    name: "properties"
-                    table_type: <recursion ...>
-                  }
-                },
-                timestamp: {
-                  alias: "timestamp"
+                person_id: {
+                  alias: "person_id"
                   type: {
-                    name: "timestamp"
+                    arg_types: [
+                      {
+                        data_type: "unknown"
+                        nullable: True
+                      },
+                      {
+                        data_type: "str"
+                        nullable: False
+                      },
+                      {
+                        data_type: "str"
+                        nullable: False
+                      }
+                    ]
+                    name: "if"
+                    return_type: {
+                      data_type: "unknown"
+                      nullable: True
+                    }
+                  }
+                },
+                properties: {
+                  alias: "properties"
+                  type: {
+                    name: "properties"
+                    table_type: <recursion ...>
+                  }
+                },
+                timestamp: {
+                  alias: "timestamp"
+                  type: {
+                    name: "timestamp"
                     table_type: <recursion ...>
                   }
                 },
@@ -2736,6 +3309,40 @@
           alias: "event_person_id"
           type: <recursion ...>
         }
+      },
+      {
+        alias: "event_issue_id"
+        expr: {
+          chain: [
+            "event_issue_id"
+          ]
+          type: {
+            name: "event_issue_id"
+            table_type: <recursion ...>
+          }
+        }
+        hidden: True
+        type: {
+          alias: "event_issue_id"
+          type: <recursion ...>
+        }
+      },
+      {
+        alias: "issue_id"
+        expr: {
+          chain: [
+            "issue_id"
+          ]
+          type: {
+            name: "issue_id"
+            table_type: <recursion ...>
+          }
+        }
+        hidden: True
+        type: {
+          alias: "issue_id"
+          type: <recursion ...>
+        }
       }
     ]
     select_from: {
@@ -3083,6 +3690,210 @@
               }
               hidden: True
               type: <recursion ...>
+            },
+            {
+              alias: "event_issue_id"
+              expr: {
+                args: [
+                  {
+                    alias: "$exception_issue_id"
+                    expr: {
+                      chain: [
+                        "properties",
+                        "$exception_issue_id"
+                      ]
+                      end: 37
+                      start: 7
+                      type: {
+                        chain: [
+                          "$exception_issue_id"
+                        ]
+                        field_type: {
+                          name: "properties"
+                          table_type: <recursion ...>
+                        }
+                      }
+                    }
+                    hidden: True
+                    type: {
+                      alias: "$exception_issue_id"
+                      type: <recursion ...>
+                    }
+                  }
+                ]
+                distinct: False
+                end: 38
+                name: "toUUID"
+                start: 0
+                type: <recursion ...>
+              }
+              hidden: True
+              type: <recursion ...>
+            },
+            {
+              alias: "issue_id"
+              expr: {
+                args: [
+                  {
+                    args: [
+                      {
+                        args: [
+                          {
+                            alias: "issue_id"
+                            expr: {
+                              chain: [
+                                "exception_issue_override",
+                                "issue_id"
+                              ]
+                              type: {
+                                name: "issue_id"
+                                table_type: {
+                                  field: "exception_issue_override"
+                                  lazy_join: {
+                                    from_field: [
+                                      "fingerprint"
+                                    ],
+                                    join_function: <function>,
+                                    join_table: {
+                                      fields: {
+                                        fingerprint: {},
+                                        issue_id: {},
+                                        team_id: {}
+                                      }
+                                    },
+                                    to_field: None
+                                  }
+                                  table_type: <recursion ...>
+                                }
+                              }
+                            }
+                            hidden: True
+                            type: {
+                              alias: "issue_id"
+                              type: <recursion ...>
+                            }
+                          }
+                        ]
+                        distinct: False
+                        name: "empty"
+                        type: {
+                          arg_types: [
+                            {
+                              data_type: "str"
+                              nullable: False
+                            }
+                          ]
+                          name: "empty"
+                          return_type: {
+                            data_type: "unknown"
+                            nullable: True
+                          }
+                        }
+                      }
+                    ]
+                    distinct: False
+                    name: "not"
+                    type: {
+                      arg_types: [
+                        <recursion ...>
+                      ]
+                      name: "not"
+                      return_type: <recursion ...>
+                    }
+                  },
+                  {
+                    alias: "issue_id"
+                    expr: {
+                      chain: [
+                        "exception_issue_override",
+                        "issue_id"
+                      ]
+                      type: {
+                        name: "issue_id"
+                        table_type: {
+                          field: "exception_issue_override"
+                          lazy_join: {
+                            from_field: [
+                              "fingerprint"
+                            ],
+                            join_function: <function>,
+                            join_table: {
+                              fields: {
+                                fingerprint: {},
+                                issue_id: {},
+                                team_id: {}
+                              }
+                            },
+                            to_field: None
+                          }
+                          table_type: <recursion ...>
+                        }
+                      }
+                    }
+                    hidden: True
+                    type: {
+                      alias: "issue_id"
+                      type: <recursion ...>
+                    }
+                  },
+                  {
+                    alias: "event_issue_id"
+                    expr: {
+                      args: [
+                        {
+                          alias: "$exception_issue_id"
+                          expr: {
+                            chain: [
+                              "properties",
+                              "$exception_issue_id"
+                            ]
+                            end: 37
+                            start: 7
+                            type: {
+                              chain: [
+                                "$exception_issue_id"
+                              ]
+                              field_type: {
+                                name: "properties"
+                                table_type: <recursion ...>
+                              }
+                            }
+                          }
+                          hidden: True
+                          type: {
+                            alias: "$exception_issue_id"
+                            type: <recursion ...>
+                          }
+                        }
+                      ]
+                      distinct: False
+                      end: 38
+                      name: "toUUID"
+                      start: 0
+                      type: {
+                        arg_types: [
+                          {
+                            data_type: "str"
+                            nullable: False
+                          }
+                        ]
+                        name: "toUUID"
+                        return_type: <recursion ...>
+                      }
+                    }
+                    hidden: True
+                    type: {
+                      alias: "event_issue_id"
+                      type: <recursion ...>
+                    }
+                  }
+                ]
+                distinct: False
+                name: "if"
+                type: <recursion ...>
+              }
+              hidden: True
+              type: <recursion ...>
             }
           ]
           select_from: {
@@ -3126,7 +3937,9 @@
                             elements_chain_ids: {},
                             elements_chain_texts: {},
                             event: {},
+                            event_issue_id: {},
                             event_person_id: {},
+                            exception_issue_override: {},
                             goe_0: {},
                             goe_1: {},
                             goe_2: {},
@@ -3137,6 +3950,7 @@
                             group_2: {},
                             group_3: {},
                             group_4: {},
+                            issue_id: {},
                             override: {},
                             pdi: {},
                             person: {},
@@ -3619,48 +4433,292 @@
                     alias: "event_person_id"
                     type: <recursion ...>
                   }
-                }
-              ]
-              select_from: {
-                table: {
-                  chain: [
-                    "events"
-                  ]
-                  type: <recursion ...>
-                }
-                type: <recursion ...>
-              }
-              type: {
-                aliases: {}
-                anonymous_tables: []
-                columns: {
-                  $group_0: <recursion ...>,
-                  $group_1: <recursion ...>,
-                  $group_2: <recursion ...>,
-                  $group_3: <recursion ...>,
-                  $group_4: <recursion ...>,
-                  $session_id: <recursion ...>,
-                  $window_id: <recursion ...>,
-                  created_at: <recursion ...>,
-                  distinct_id: <recursion ...>,
-                  elements_chain: <recursion ...>,
-                  elements_chain_elements: <recursion ...>,
-                  elements_chain_href: <recursion ...>,
-                  elements_chain_ids: <recursion ...>,
-                  elements_chain_texts: <recursion ...>,
-                  event: <recursion ...>,
-                  event_person_id: <recursion ...>,
-                  person_id: <recursion ...>,
-                  properties: <recursion ...>,
-                  timestamp: <recursion ...>,
-                  uuid: <recursion ...>
-                }
-                ctes: {}
-                tables: {
-                  events: <recursion ...>
-                }
-              }
-            }
+                },
+                {
+                  alias: "event_issue_id"
+                  expr: {
+                    args: [
+                      {
+                        alias: "$exception_issue_id"
+                        expr: {
+                          chain: [
+                            "properties",
+                            "$exception_issue_id"
+                          ]
+                          end: 37
+                          start: 7
+                          type: {
+                            chain: [
+                              "$exception_issue_id"
+                            ]
+                            field_type: {
+                              name: "properties"
+                              table_type: <recursion ...>
+                            }
+                          }
+                        }
+                        hidden: True
+                        type: {
+                          alias: "$exception_issue_id"
+                          type: <recursion ...>
+                        }
+                      }
+                    ]
+                    distinct: False
+                    end: 38
+                    name: "toUUID"
+                    start: 0
+                    type: {
+                      arg_types: [
+                        {
+                          data_type: "str"
+                          nullable: False
+                        }
+                      ]
+                      name: "toUUID"
+                      return_type: {
+                        data_type: "unknown"
+                        nullable: True
+                      }
+                    }
+                  }
+                  hidden: True
+                  type: {
+                    alias: "event_issue_id"
+                    type: <recursion ...>
+                  }
+                },
+                {
+                  alias: "issue_id"
+                  expr: {
+                    args: [
+                      {
+                        args: [
+                          {
+                            args: [
+                              {
+                                alias: "issue_id"
+                                expr: {
+                                  chain: [
+                                    "exception_issue_override",
+                                    "issue_id"
+                                  ]
+                                  type: {
+                                    name: "issue_id"
+                                    table_type: {
+                                      field: "exception_issue_override"
+                                      lazy_join: {
+                                        from_field: [
+                                          "fingerprint"
+                                        ],
+                                        join_function: <function>,
+                                        join_table: {
+                                          fields: {
+                                            fingerprint: {},
+                                            issue_id: {},
+                                            team_id: {}
+                                          }
+                                        },
+                                        to_field: None
+                                      }
+                                      table_type: <recursion ...>
+                                    }
+                                  }
+                                }
+                                hidden: True
+                                type: {
+                                  alias: "issue_id"
+                                  type: <recursion ...>
+                                }
+                              }
+                            ]
+                            distinct: False
+                            name: "empty"
+                            type: {
+                              arg_types: [
+                                {
+                                  data_type: "str"
+                                  nullable: False
+                                }
+                              ]
+                              name: "empty"
+                              return_type: {
+                                data_type: "unknown"
+                                nullable: True
+                              }
+                            }
+                          }
+                        ]
+                        distinct: False
+                        name: "not"
+                        type: {
+                          arg_types: [
+                            <recursion ...>
+                          ]
+                          name: "not"
+                          return_type: {
+                            data_type: "unknown"
+                            nullable: True
+                          }
+                        }
+                      },
+                      {
+                        alias: "issue_id"
+                        expr: {
+                          chain: [
+                            "exception_issue_override",
+                            "issue_id"
+                          ]
+                          type: {
+                            name: "issue_id"
+                            table_type: {
+                              field: "exception_issue_override"
+                              lazy_join: {
+                                from_field: [
+                                  "fingerprint"
+                                ],
+                                join_function: <function>,
+                                join_table: {
+                                  fields: {
+                                    fingerprint: {},
+                                    issue_id: {},
+                                    team_id: {}
+                                  }
+                                },
+                                to_field: None
+                              }
+                              table_type: <recursion ...>
+                            }
+                          }
+                        }
+                        hidden: True
+                        type: {
+                          alias: "issue_id"
+                          type: <recursion ...>
+                        }
+                      },
+                      {
+                        alias: "event_issue_id"
+                        expr: {
+                          args: [
+                            {
+                              alias: "$exception_issue_id"
+                              expr: {
+                                chain: [
+                                  "properties",
+                                  "$exception_issue_id"
+                                ]
+                                end: 37
+                                start: 7
+                                type: {
+                                  chain: [
+                                    "$exception_issue_id"
+                                  ]
+                                  field_type: {
+                                    name: "properties"
+                                    table_type: <recursion ...>
+                                  }
+                                }
+                              }
+                              hidden: True
+                              type: {
+                                alias: "$exception_issue_id"
+                                type: <recursion ...>
+                              }
+                            }
+                          ]
+                          distinct: False
+                          end: 38
+                          name: "toUUID"
+                          start: 0
+                          type: {
+                            arg_types: [
+                              {
+                                data_type: "str"
+                                nullable: False
+                              }
+                            ]
+                            name: "toUUID"
+                            return_type: {
+                              data_type: "unknown"
+                              nullable: True
+                            }
+                          }
+                        }
+                        hidden: True
+                        type: {
+                          alias: "event_issue_id"
+                          type: <recursion ...>
+                        }
+                      }
+                    ]
+                    distinct: False
+                    name: "if"
+                    type: {
+                      arg_types: [
+                        <recursion ...>,
+                        {
+                          data_type: "str"
+                          nullable: False
+                        },
+                        <recursion ...>
+                      ]
+                      name: "if"
+                      return_type: {
+                        data_type: "unknown"
+                        nullable: True
+                      }
+                    }
+                  }
+                  hidden: True
+                  type: {
+                    alias: "issue_id"
+                    type: <recursion ...>
+                  }
+                }
+              ]
+              select_from: {
+                table: {
+                  chain: [
+                    "events"
+                  ]
+                  type: <recursion ...>
+                }
+                type: <recursion ...>
+              }
+              type: {
+                aliases: {}
+                anonymous_tables: []
+                columns: {
+                  $group_0: <recursion ...>,
+                  $group_1: <recursion ...>,
+                  $group_2: <recursion ...>,
+                  $group_3: <recursion ...>,
+                  $group_4: <recursion ...>,
+                  $session_id: <recursion ...>,
+                  $window_id: <recursion ...>,
+                  created_at: <recursion ...>,
+                  distinct_id: <recursion ...>,
+                  elements_chain: <recursion ...>,
+                  elements_chain_elements: <recursion ...>,
+                  elements_chain_href: <recursion ...>,
+                  elements_chain_ids: <recursion ...>,
+                  elements_chain_texts: <recursion ...>,
+                  event: <recursion ...>,
+                  event_issue_id: <recursion ...>,
+                  event_person_id: <recursion ...>,
+                  issue_id: <recursion ...>,
+                  person_id: <recursion ...>,
+                  properties: <recursion ...>,
+                  timestamp: <recursion ...>,
+                  uuid: <recursion ...>
+                }
+                ctes: {}
+                tables: {
+                  events: <recursion ...>
+                }
+              }
+            }
             set_operator: "UNION ALL"
           }
         ]
@@ -3694,7 +4752,9 @@
         elements_chain_ids: <recursion ...>,
         elements_chain_texts: <recursion ...>,
         event: <recursion ...>,
+        event_issue_id: <recursion ...>,
         event_person_id: <recursion ...>,
+        issue_id: <recursion ...>,
         person_id: <recursion ...>,
         properties: <recursion ...>,
         timestamp: <recursion ...>,
@@ -3950,7 +5010,9 @@
                   elements_chain_ids: {},
                   elements_chain_texts: {},
                   event: {},
+                  event_issue_id: {},
                   event_person_id: {},
+                  exception_issue_override: {},
                   goe_0: {},
                   goe_1: {},
                   goe_2: {},
@@ -3961,6 +5023,7 @@
                   group_2: {},
                   group_3: {},
                   group_4: {},
+                  issue_id: {},
                   override: {},
                   pdi: {},
                   person: {},
@@ -4443,42 +5506,286 @@
           alias: "event_person_id"
           type: <recursion ...>
         }
-      }
-    ]
-    select_from: {
-      table: {
-        chain: [
-          "events"
-        ]
-        type: <recursion ...>
-      }
-      type: <recursion ...>
-    }
-    type: {
-      aliases: {}
-      anonymous_tables: []
-      columns: {
-        $group_0: <recursion ...>,
-        $group_1: <recursion ...>,
-        $group_2: <recursion ...>,
-        $group_3: <recursion ...>,
-        $group_4: <recursion ...>,
-        $session_id: <recursion ...>,
-        $window_id: <recursion ...>,
-        created_at: <recursion ...>,
-        distinct_id: <recursion ...>,
-        elements_chain: <recursion ...>,
-        elements_chain_elements: <recursion ...>,
-        elements_chain_href: <recursion ...>,
-        elements_chain_ids: <recursion ...>,
-        elements_chain_texts: <recursion ...>,
-        event: <recursion ...>,
-        event_person_id: <recursion ...>,
-        person_id: <recursion ...>,
-        properties: <recursion ...>,
-        timestamp: <recursion ...>,
-        uuid: <recursion ...>
-      }
+      },
+      {
+        alias: "event_issue_id"
+        expr: {
+          args: [
+            {
+              alias: "$exception_issue_id"
+              expr: {
+                chain: [
+                  "properties",
+                  "$exception_issue_id"
+                ]
+                end: 37
+                start: 7
+                type: {
+                  chain: [
+                    "$exception_issue_id"
+                  ]
+                  field_type: {
+                    name: "properties"
+                    table_type: <recursion ...>
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "$exception_issue_id"
+                type: <recursion ...>
+              }
+            }
+          ]
+          distinct: False
+          end: 38
+          name: "toUUID"
+          start: 0
+          type: {
+            arg_types: [
+              {
+                data_type: "str"
+                nullable: False
+              }
+            ]
+            name: "toUUID"
+            return_type: {
+              data_type: "unknown"
+              nullable: True
+            }
+          }
+        }
+        hidden: True
+        type: {
+          alias: "event_issue_id"
+          type: <recursion ...>
+        }
+      },
+      {
+        alias: "issue_id"
+        expr: {
+          args: [
+            {
+              args: [
+                {
+                  args: [
+                    {
+                      alias: "issue_id"
+                      expr: {
+                        chain: [
+                          "exception_issue_override",
+                          "issue_id"
+                        ]
+                        type: {
+                          name: "issue_id"
+                          table_type: {
+                            field: "exception_issue_override"
+                            lazy_join: {
+                              from_field: [
+                                "fingerprint"
+                              ],
+                              join_function: <function>,
+                              join_table: {
+                                fields: {
+                                  fingerprint: {},
+                                  issue_id: {},
+                                  team_id: {}
+                                }
+                              },
+                              to_field: None
+                            }
+                            table_type: <recursion ...>
+                          }
+                        }
+                      }
+                      hidden: True
+                      type: {
+                        alias: "issue_id"
+                        type: <recursion ...>
+                      }
+                    }
+                  ]
+                  distinct: False
+                  name: "empty"
+                  type: {
+                    arg_types: [
+                      {
+                        data_type: "str"
+                        nullable: False
+                      }
+                    ]
+                    name: "empty"
+                    return_type: {
+                      data_type: "unknown"
+                      nullable: True
+                    }
+                  }
+                }
+              ]
+              distinct: False
+              name: "not"
+              type: {
+                arg_types: [
+                  <recursion ...>
+                ]
+                name: "not"
+                return_type: {
+                  data_type: "unknown"
+                  nullable: True
+                }
+              }
+            },
+            {
+              alias: "issue_id"
+              expr: {
+                chain: [
+                  "exception_issue_override",
+                  "issue_id"
+                ]
+                type: {
+                  name: "issue_id"
+                  table_type: {
+                    field: "exception_issue_override"
+                    lazy_join: {
+                      from_field: [
+                        "fingerprint"
+                      ],
+                      join_function: <function>,
+                      join_table: {
+                        fields: {
+                          fingerprint: {},
+                          issue_id: {},
+                          team_id: {}
+                        }
+                      },
+                      to_field: None
+                    }
+                    table_type: <recursion ...>
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "issue_id"
+                type: <recursion ...>
+              }
+            },
+            {
+              alias: "event_issue_id"
+              expr: {
+                args: [
+                  {
+                    alias: "$exception_issue_id"
+                    expr: {
+                      chain: [
+                        "properties",
+                        "$exception_issue_id"
+                      ]
+                      end: 37
+                      start: 7
+                      type: {
+                        chain: [
+                          "$exception_issue_id"
+                        ]
+                        field_type: {
+                          name: "properties"
+                          table_type: <recursion ...>
+                        }
+                      }
+                    }
+                    hidden: True
+                    type: {
+                      alias: "$exception_issue_id"
+                      type: <recursion ...>
+                    }
+                  }
+                ]
+                distinct: False
+                end: 38
+                name: "toUUID"
+                start: 0
+                type: {
+                  arg_types: [
+                    {
+                      data_type: "str"
+                      nullable: False
+                    }
+                  ]
+                  name: "toUUID"
+                  return_type: {
+                    data_type: "unknown"
+                    nullable: True
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "event_issue_id"
+                type: <recursion ...>
+              }
+            }
+          ]
+          distinct: False
+          name: "if"
+          type: {
+            arg_types: [
+              <recursion ...>,
+              {
+                data_type: "str"
+                nullable: False
+              },
+              <recursion ...>
+            ]
+            name: "if"
+            return_type: {
+              data_type: "unknown"
+              nullable: True
+            }
+          }
+        }
+        hidden: True
+        type: {
+          alias: "issue_id"
+          type: <recursion ...>
+        }
+      }
+    ]
+    select_from: {
+      table: {
+        chain: [
+          "events"
+        ]
+        type: <recursion ...>
+      }
+      type: <recursion ...>
+    }
+    type: {
+      aliases: {}
+      anonymous_tables: []
+      columns: {
+        $group_0: <recursion ...>,
+        $group_1: <recursion ...>,
+        $group_2: <recursion ...>,
+        $group_3: <recursion ...>,
+        $group_4: <recursion ...>,
+        $session_id: <recursion ...>,
+        $window_id: <recursion ...>,
+        created_at: <recursion ...>,
+        distinct_id: <recursion ...>,
+        elements_chain: <recursion ...>,
+        elements_chain_elements: <recursion ...>,
+        elements_chain_href: <recursion ...>,
+        elements_chain_ids: <recursion ...>,
+        elements_chain_texts: <recursion ...>,
+        event: <recursion ...>,
+        event_issue_id: <recursion ...>,
+        event_person_id: <recursion ...>,
+        issue_id: <recursion ...>,
+        person_id: <recursion ...>,
+        properties: <recursion ...>,
+        timestamp: <recursion ...>,
+        uuid: <recursion ...>
+      }
       ctes: {}
       tables: {
         events: <recursion ...>
@@ -4519,7 +5826,9 @@
                     elements_chain_ids: {},
                     elements_chain_texts: {},
                     event: {},
+                    event_issue_id: {},
                     event_person_id: {},
+                    exception_issue_override: {},
                     goe_0: {},
                     goe_1: {},
                     goe_2: {},
@@ -4530,6 +5839,7 @@
                     group_2: {},
                     group_3: {},
                     group_4: {},
+                    issue_id: {},
                     override: {},
                     pdi: {},
                     person: {},
@@ -5013,6 +6323,248 @@
           alias: "event_person_id"
           type: <recursion ...>
         }
+      },
+      {
+        alias: "event_issue_id"
+        expr: {
+          args: [
+            {
+              alias: "$exception_issue_id"
+              expr: {
+                chain: [
+                  "properties",
+                  "$exception_issue_id"
+                ]
+                end: 37
+                start: 7
+                type: {
+                  chain: [
+                    "$exception_issue_id"
+                  ]
+                  field_type: {
+                    name: "properties"
+                    table_type: <recursion ...>
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "$exception_issue_id"
+                type: <recursion ...>
+              }
+            }
+          ]
+          distinct: False
+          end: 38
+          name: "toUUID"
+          start: 0
+          type: {
+            arg_types: [
+              {
+                data_type: "str"
+                nullable: False
+              }
+            ]
+            name: "toUUID"
+            return_type: {
+              data_type: "unknown"
+              nullable: True
+            }
+          }
+        }
+        hidden: True
+        type: {
+          alias: "event_issue_id"
+          type: <recursion ...>
+        }
+      },
+      {
+        alias: "issue_id"
+        expr: {
+          args: [
+            {
+              args: [
+                {
+                  args: [
+                    {
+                      alias: "issue_id"
+                      expr: {
+                        chain: [
+                          "exception_issue_override",
+                          "issue_id"
+                        ]
+                        type: {
+                          name: "issue_id"
+                          table_type: {
+                            field: "exception_issue_override"
+                            lazy_join: {
+                              from_field: [
+                                "fingerprint"
+                              ],
+                              join_function: <function>,
+                              join_table: {
+                                fields: {
+                                  fingerprint: {},
+                                  issue_id: {},
+                                  team_id: {}
+                                }
+                              },
+                              to_field: None
+                            }
+                            table_type: <recursion ...>
+                          }
+                        }
+                      }
+                      hidden: True
+                      type: {
+                        alias: "issue_id"
+                        type: <recursion ...>
+                      }
+                    }
+                  ]
+                  distinct: False
+                  name: "empty"
+                  type: {
+                    arg_types: [
+                      {
+                        data_type: "str"
+                        nullable: False
+                      }
+                    ]
+                    name: "empty"
+                    return_type: {
+                      data_type: "unknown"
+                      nullable: True
+                    }
+                  }
+                }
+              ]
+              distinct: False
+              name: "not"
+              type: {
+                arg_types: [
+                  <recursion ...>
+                ]
+                name: "not"
+                return_type: {
+                  data_type: "unknown"
+                  nullable: True
+                }
+              }
+            },
+            {
+              alias: "issue_id"
+              expr: {
+                chain: [
+                  "exception_issue_override",
+                  "issue_id"
+                ]
+                type: {
+                  name: "issue_id"
+                  table_type: {
+                    field: "exception_issue_override"
+                    lazy_join: {
+                      from_field: [
+                        "fingerprint"
+                      ],
+                      join_function: <function>,
+                      join_table: {
+                        fields: {
+                          fingerprint: {},
+                          issue_id: {},
+                          team_id: {}
+                        }
+                      },
+                      to_field: None
+                    }
+                    table_type: <recursion ...>
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "issue_id"
+                type: <recursion ...>
+              }
+            },
+            {
+              alias: "event_issue_id"
+              expr: {
+                args: [
+                  {
+                    alias: "$exception_issue_id"
+                    expr: {
+                      chain: [
+                        "properties",
+                        "$exception_issue_id"
+                      ]
+                      end: 37
+                      start: 7
+                      type: {
+                        chain: [
+                          "$exception_issue_id"
+                        ]
+                        field_type: {
+                          name: "properties"
+                          table_type: <recursion ...>
+                        }
+                      }
+                    }
+                    hidden: True
+                    type: {
+                      alias: "$exception_issue_id"
+                      type: <recursion ...>
+                    }
+                  }
+                ]
+                distinct: False
+                end: 38
+                name: "toUUID"
+                start: 0
+                type: {
+                  arg_types: [
+                    {
+                      data_type: "str"
+                      nullable: False
+                    }
+                  ]
+                  name: "toUUID"
+                  return_type: {
+                    data_type: "unknown"
+                    nullable: True
+                  }
+                }
+              }
+              hidden: True
+              type: {
+                alias: "event_issue_id"
+                type: <recursion ...>
+              }
+            }
+          ]
+          distinct: False
+          name: "if"
+          type: {
+            arg_types: [
+              <recursion ...>,
+              {
+                data_type: "str"
+                nullable: False
+              },
+              <recursion ...>
+            ]
+            name: "if"
+            return_type: {
+              data_type: "unknown"
+              nullable: True
+            }
+          }
+        }
+        hidden: True
+        type: {
+          alias: "issue_id"
+          type: <recursion ...>
+        }
       }
     ]
     select_from: {
@@ -5044,7 +6596,9 @@
         elements_chain_ids: <recursion ...>,
         elements_chain_texts: <recursion ...>,
         event: <recursion ...>,
+        event_issue_id: <recursion ...>,
         event_person_id: <recursion ...>,
+        issue_id: <recursion ...>,
         person_id: <recursion ...>,
         properties: <recursion ...>,
         timestamp: <recursion ...>,
@@ -5090,7 +6644,9 @@
                       elements_chain_ids: {},
                       elements_chain_texts: {},
                       event: {},
+                      event_issue_id: {},
                       event_person_id: {},
+                      exception_issue_override: {},
                       goe_0: {},
                       goe_1: {},
                       goe_2: {},
@@ -5101,6 +6657,7 @@
                       group_2: {},
                       group_3: {},
                       group_4: {},
+                      issue_id: {},
                       override: {},
                       pdi: {},
                       person: {},
@@ -5195,7 +6752,9 @@
                       elements_chain_ids: {},
                       elements_chain_texts: {},
                       event: {},
+                      event_issue_id: {},
                       event_person_id: {},
+                      exception_issue_override: {},
                       goe_0: {},
                       goe_1: {},
                       goe_2: {},
@@ -5206,6 +6765,7 @@
                       group_2: {},
                       group_3: {},
                       group_4: {},
+                      issue_id: {},
                       override: {},
                       pdi: {},
                       person: {},
@@ -5580,7 +7140,9 @@
                   elements_chain_ids: {},
                   elements_chain_texts: {},
                   event: {},
+                  event_issue_id: {},
                   event_person_id: {},
+                  exception_issue_override: {},
                   goe_0: {},
                   goe_1: {},
                   goe_2: {},
@@ -5591,6 +7153,7 @@
                   group_2: {},
                   group_3: {},
                   group_4: {},
+                  issue_id: {},
                   override: {},
                   pdi: {},
                   person: {},
@@ -5719,7 +7282,9 @@
                     elements_chain_ids: {},
                     elements_chain_texts: {},
                     event: {},
+                    event_issue_id: {},
                     event_person_id: {},
+                    exception_issue_override: {},
                     goe_0: {},
                     goe_1: {},
                     goe_2: {},
@@ -5730,6 +7295,7 @@
                     group_2: {},
                     group_3: {},
                     group_4: {},
+                    issue_id: {},
                     override: {},
                     pdi: {},
                     person: {},
@@ -5862,7 +7428,9 @@
                       elements_chain_ids: {},
                       elements_chain_texts: {},
                       event: {},
+                      event_issue_id: {},
                       event_person_id: {},
+                      exception_issue_override: {},
                       goe_0: {},
                       goe_1: {},
                       goe_2: {},
@@ -5873,6 +7441,7 @@
                       group_2: {},
                       group_3: {},
                       group_4: {},
+                      issue_id: {},
                       override: {},
                       pdi: {},
                       person: {},
@@ -6041,7 +7610,9 @@
                               elements_chain_ids: {},
                               elements_chain_texts: {},
                               event: {},
+                              event_issue_id: {},
                               event_person_id: {},
+                              exception_issue_override: {},
                               goe_0: {},
                               goe_1: {},
                               goe_2: {},
@@ -6052,6 +7623,7 @@
                               group_2: {},
                               group_3: {},
                               group_4: {},
+                              issue_id: {},
                               override: {},
                               pdi: {},
                               person: {},
@@ -6225,7 +7797,9 @@
                   elements_chain_ids: {},
                   elements_chain_texts: {},
                   event: {},
+                  event_issue_id: {},
                   event_person_id: {},
+                  exception_issue_override: {},
                   goe_0: {},
                   goe_1: {},
                   goe_2: {},
@@ -6236,6 +7810,7 @@
                   group_2: {},
                   group_3: {},
                   group_4: {},
+                  issue_id: {},
                   override: {},
                   pdi: {},
                   person: {},
@@ -6362,7 +7937,9 @@
                     elements_chain_ids: {},
                     elements_chain_texts: {},
                     event: {},
+                    event_issue_id: {},
                     event_person_id: {},
+                    exception_issue_override: {},
                     goe_0: {},
                     goe_1: {},
                     goe_2: {},
@@ -6373,6 +7950,7 @@
                     group_2: {},
                     group_3: {},
                     group_4: {},
+                    issue_id: {},
                     override: {},
                     pdi: {},
                     person: {},
@@ -6500,7 +8078,9 @@
                   elements_chain_ids: {},
                   elements_chain_texts: {},
                   event: {},
+                  event_issue_id: {},
                   event_person_id: {},
+                  exception_issue_override: {},
                   goe_0: {},
                   goe_1: {},
                   goe_2: {},
@@ -6511,6 +8091,7 @@
                   group_2: {},
                   group_3: {},
                   group_4: {},
+                  issue_id: {},
                   override: {},
                   pdi: {},
                   person: {},
@@ -6625,7 +8206,9 @@
                     elements_chain_ids: {},
                     elements_chain_texts: {},
                     event: {},
+                    event_issue_id: {},
                     event_person_id: {},
+                    exception_issue_override: {},
                     goe_0: {},
                     goe_1: {},
                     goe_2: {},
@@ -6636,6 +8219,7 @@
                     group_2: {},
                     group_3: {},
                     group_4: {},
+                    issue_id: {},
                     override: {},
                     pdi: {},
                     person: {},
@@ -6836,7 +8420,9 @@
                     elements_chain_ids: {},
                     elements_chain_texts: {},
                     event: {},
+                    event_issue_id: {},
                     event_person_id: {},
+                    exception_issue_override: {},
                     goe_0: {},
                     goe_1: {},
                     goe_2: {},
@@ -6847,6 +8433,7 @@
                     group_2: {},
                     group_3: {},
                     group_4: {},
+                    issue_id: {},
                     override: {},
                     pdi: {},
                     person: {},
@@ -6938,7 +8525,9 @@
                         elements_chain_ids: {},
                         elements_chain_texts: {},
                         event: {},
+                        event_issue_id: {},
                         event_person_id: {},
+                        exception_issue_override: {},
                         goe_0: {},
                         goe_1: {},
                         goe_2: {},
@@ -6949,6 +8538,7 @@
                         group_2: {},
                         group_3: {},
                         group_4: {},
+                        issue_id: {},
                         override: {},
                         pdi: {},
                         person: {},
@@ -7052,7 +8642,9 @@
                   elements_chain_ids: {},
                   elements_chain_texts: {},
                   event: {},
+                  event_issue_id: {},
                   event_person_id: {},
+                  exception_issue_override: {},
                   goe_0: {},
                   goe_1: {},
                   goe_2: {},
@@ -7063,6 +8655,7 @@
                   group_2: {},
                   group_3: {},
                   group_4: {},
+                  issue_id: {},
                   override: {},
                   pdi: {},
                   person: {},
diff --git a/posthog/hogql/test/test_metadata.py b/posthog/hogql/test/test_metadata.py
index ca617283b51be..720d71bebb333 100644
--- a/posthog/hogql/test/test_metadata.py
+++ b/posthog/hogql/test/test_metadata.py
@@ -464,3 +464,52 @@ def test_is_valid_view_is_false_when_using_scoped_asterisk(self):
                 "errors": [],
             },
         )
+
+    def test_table_collector_basic_select(self):
+        metadata = self._select("SELECT event FROM events")
+        self.assertEqual(metadata.table_names, ["events"])
+
+    def test_table_collector_multiple_tables(self):
+        metadata = self._select(
+            "SELECT events.event, persons.name FROM events JOIN persons ON events.person_id = persons.id"
+        )
+        self.assertEqual(sorted(metadata.table_names or []), sorted(["events", "persons"]))
+
+    def test_table_collector_with_cte(self):
+        metadata = self._select("""
+            WITH events_count AS (
+                SELECT count(*) as count FROM events
+            )
+            SELECT * FROM events_count
+        """)
+        self.assertEqual(sorted(metadata.table_names or []), sorted(["events"]))
+
+    def test_table_collector_subquery(self):
+        metadata = self._select("""
+            SELECT * FROM (
+                SELECT event FROM events
+                UNION ALL
+                SELECT event FROM events_summary
+            )
+        """)
+        self.assertEqual(sorted(metadata.table_names or []), sorted(["events", "events_summary"]))
+
+    def test_table_in_filter(self):
+        metadata = self._select("SELECT * FROM events WHERE event IN (SELECT event FROM events_summary)")
+        self.assertEqual(sorted(metadata.table_names or []), sorted(["events", "events_summary"]))
+
+    def test_table_collector_complex_query(self):
+        metadata = self._select("""
+            WITH user_counts AS (
+                SELECT person_id, count(*) as count
+                FROM events
+                GROUP BY person_id
+            )
+            SELECT
+                p.name,
+                uc.count
+            FROM persons p
+            LEFT JOIN user_counts uc ON p.id = uc.person_id
+            LEFT JOIN cohorts c ON p.cohort_id = c.id
+        """)
+        self.assertEqual(sorted(metadata.table_names or []), sorted(["events", "persons", "cohorts"]))
diff --git a/posthog/hogql/test/test_printer.py b/posthog/hogql/test/test_printer.py
index 3d369f5574f4e..dc5a1b3831e46 100644
--- a/posthog/hogql/test/test_printer.py
+++ b/posthog/hogql/test/test_printer.py
@@ -460,14 +460,22 @@ def test_hogql_properties_materialized_json_access(self):
             self.assertEqual(1 + 2, 3)
             return
 
-        materialize("events", "withmat")
         context = HogQLContext(team_id=self.team.pk)
+        materialize("events", "withmat")
         self.assertEqual(
             self._expr("properties.withmat.json.yet", context),
             "replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(nullIf(nullIf(events.mat_withmat, ''), 'null'), %(hogql_val_0)s, %(hogql_val_1)s), ''), 'null'), '^\"|\"$', '')",
         )
         self.assertEqual(context.values, {"hogql_val_0": "json", "hogql_val_1": "yet"})
 
+        context = HogQLContext(team_id=self.team.pk)
+        materialize("events", "withmat_nullable", is_nullable=True)
+        self.assertEqual(
+            self._expr("properties.withmat_nullable.json.yet", context),
+            "replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.mat_withmat_nullable, %(hogql_val_0)s, %(hogql_val_1)s), ''), 'null'), '^\"|\"$', '')",
+        )
+        self.assertEqual(context.values, {"hogql_val_0": "json", "hogql_val_1": "yet"})
+
     def test_materialized_fields_and_properties(self):
         try:
             from ee.clickhouse.materialized_columns.analyze import materialize
@@ -499,6 +507,12 @@ def test_materialized_fields_and_properties(self):
             "nullIf(nullIf(events.`mat_$browser_______`, ''), 'null')",
         )
 
+        materialize("events", "nullable_property", is_nullable=True)
+        self.assertEqual(
+            self._expr("properties['nullable_property']"),
+            "events.mat_nullable_property",
+        )
+
     def test_property_groups(self):
         context = HogQLContext(
             team_id=self.team.pk,
@@ -832,9 +846,7 @@ def test_functions(self):
             self._expr("toUUID('470f9b15-ff43-402a-af9f-2ed7c526a6cf')", context),
             "accurateCastOrNull(%(hogql_val_4)s, %(hogql_val_5)s)",
         )
-        self.assertEqual(
-            self._expr("toDecimal('3.14')", context), "accurateCastOrNull(%(hogql_val_6)s, %(hogql_val_7)s)"
-        )
+        self.assertEqual(self._expr("toDecimal('3.14', 2)", context), "toDecimal64OrNull(%(hogql_val_6)s, 2)")
         self.assertEqual(self._expr("quantile(0.95)( event )"), "quantile(0.95)(events.event)")
 
     def test_expr_parse_errors(self):
@@ -1603,18 +1615,18 @@ def test_field_nullable_boolean(self):
         )
         assert generated_sql_statements1 == (
             f"SELECT "
-            "ifNull(equals(transform(toString(nullIf(nullIf(events.mat_is_boolean, ''), 'null')), %(hogql_val_0)s, %(hogql_val_1)s, NULL), 1), 0), "
-            "ifNull(equals(transform(toString(nullIf(nullIf(events.mat_is_boolean, ''), 'null')), %(hogql_val_2)s, %(hogql_val_3)s, NULL), 0), 0), "
-            "isNull(transform(toString(nullIf(nullIf(events.mat_is_boolean, ''), 'null')), %(hogql_val_4)s, %(hogql_val_5)s, NULL)) "
+            "ifNull(equals(toBool(transform(toString(nullIf(nullIf(events.mat_is_boolean, ''), 'null')), %(hogql_val_0)s, %(hogql_val_1)s, NULL)), 1), 0), "
+            "ifNull(equals(toBool(transform(toString(nullIf(nullIf(events.mat_is_boolean, ''), 'null')), %(hogql_val_2)s, %(hogql_val_3)s, NULL)), 0), 0), "
+            "isNull(toBool(transform(toString(nullIf(nullIf(events.mat_is_boolean, ''), 'null')), %(hogql_val_4)s, %(hogql_val_5)s, NULL))) "
             f"FROM events WHERE equals(events.team_id, {self.team.pk}) LIMIT {MAX_SELECT_RETURNED_ROWS}"
         )
         assert context.values == {
             "hogql_val_0": ["true", "false"],
-            "hogql_val_1": [True, False],
+            "hogql_val_1": [1, 0],
             "hogql_val_2": ["true", "false"],
-            "hogql_val_3": [True, False],
+            "hogql_val_3": [1, 0],
             "hogql_val_4": ["true", "false"],
-            "hogql_val_5": [True, False],
+            "hogql_val_5": [1, 0],
         }
 
     def test_field_nullable_like(self):
diff --git a/posthog/hogql/transforms/in_cohort.py b/posthog/hogql/transforms/in_cohort.py
index 418b097e1d07d..98673f00bb392 100644
--- a/posthog/hogql/transforms/in_cohort.py
+++ b/posthog/hogql/transforms/in_cohort.py
@@ -94,9 +94,9 @@ def _resolve_cohorts(
                 raise QueryError("IN COHORT only works with constant arguments", node=arg)
 
             if (isinstance(arg.value, int) or isinstance(arg.value, float)) and not isinstance(arg.value, bool):
-                int_cohorts = Cohort.objects.filter(id=int(arg.value), team_id=self.context.team_id).values_list(
-                    "id", "is_static", "version"
-                )
+                int_cohorts = Cohort.objects.filter(
+                    id=int(arg.value), team__project_id=self.context.project_id
+                ).values_list("id", "is_static", "version")
                 if len(int_cohorts) == 1:
                     if node.op == ast.CompareOperationOp.NotInCohort:
                         raise QueryError("NOT IN COHORT is not supported by this cohort mode")
@@ -110,9 +110,9 @@ def _resolve_cohorts(
                 raise QueryError(f"Could not find cohort with ID {arg.value}", node=arg)
 
             if isinstance(arg.value, str):
-                str_cohorts = Cohort.objects.filter(name=arg.value, team_id=self.context.team_id).values_list(
-                    "id", "is_static", "version"
-                )
+                str_cohorts = Cohort.objects.filter(
+                    name=arg.value, team__project_id=self.context.project_id
+                ).values_list("id", "is_static", "version")
                 if len(str_cohorts) == 1:
                     if node.op == ast.CompareOperationOp.NotInCohort:
                         raise QueryError("NOT IN COHORT is not supported by this cohort mode")
@@ -288,9 +288,9 @@ def visit_compare_operation(self, node: ast.CompareOperation):
             from posthog.models import Cohort
 
             if (isinstance(arg.value, int) or isinstance(arg.value, float)) and not isinstance(arg.value, bool):
-                cohorts = Cohort.objects.filter(id=int(arg.value), team_id=self.context.team_id).values_list(
-                    "id", "is_static", "version", "name"
-                )
+                cohorts = Cohort.objects.filter(
+                    id=int(arg.value), team__project_id=self.context.project_id
+                ).values_list("id", "is_static", "version", "name")
                 if len(cohorts) == 1:
                     self.context.add_notice(
                         start=arg.start,
@@ -310,7 +310,7 @@ def visit_compare_operation(self, node: ast.CompareOperation):
                 raise QueryError(f"Could not find cohort with ID {arg.value}", node=arg)
 
             if isinstance(arg.value, str):
-                cohorts2 = Cohort.objects.filter(name=arg.value, team_id=self.context.team_id).values_list(
+                cohorts2 = Cohort.objects.filter(name=arg.value, team__project_id=self.context.project_id).values_list(
                     "id", "is_static", "version"
                 )
                 if len(cohorts2) == 1:
diff --git a/posthog/hogql/transforms/property_types.py b/posthog/hogql/transforms/property_types.py
index da36de8d988ea..e561607629f1f 100644
--- a/posthog/hogql/transforms/property_types.py
+++ b/posthog/hogql/transforms/property_types.py
@@ -1,6 +1,10 @@
-from typing import Literal, Optional, cast
+from typing import Literal, cast
 
-from posthog.clickhouse.materialized_columns import TablesWithMaterializedColumns, get_enabled_materialized_columns
+from posthog.clickhouse.materialized_columns import (
+    MaterializedColumn,
+    TablesWithMaterializedColumns,
+    get_materialized_column_for_property,
+)
 from posthog.hogql import ast
 from posthog.hogql.context import HogQLContext
 from posthog.hogql.database.models import (
@@ -221,12 +225,17 @@ def _field_type_to_property_call(self, node: ast.Field, field_type: str):
             return ast.Call(name="toFloat", args=[node])
         if field_type == "Boolean":
             return ast.Call(
-                name="transform",
+                name="toBool",
                 args=[
-                    ast.Call(name="toString", args=[node]),
-                    ast.Constant(value=["true", "false"]),
-                    ast.Constant(value=[True, False]),
-                    ast.Constant(value=None),
+                    ast.Call(
+                        name="transform",
+                        args=[
+                            ast.Call(name="toString", args=[node]),
+                            ast.Constant(value=["true", "false"]),
+                            ast.Constant(value=[1, 0]),
+                            ast.Constant(value=None),
+                        ],
+                    )
                 ],
             )
         return node
@@ -253,7 +262,7 @@ def _add_property_notice(
 
         message = f"{property_type.capitalize()} property '{property_name}' is of type '{field_type}'."
         if self.context.debug:
-            if materialized_column:
+            if materialized_column is not None:
                 message += " This property is materialized ⚡️."
             else:
                 message += " This property is not materialized 🐢."
@@ -272,6 +281,7 @@ def _add_notice(self, node: ast.Field, message: str):
 
     def _get_materialized_column(
         self, table_name: str, property_name: PropertyName, field_name: TableColumn
-    ) -> Optional[str]:
-        materialized_columns = get_enabled_materialized_columns(cast(TablesWithMaterializedColumns, table_name))
-        return materialized_columns.get((property_name, field_name), None)
+    ) -> MaterializedColumn | None:
+        return get_materialized_column_for_property(
+            cast(TablesWithMaterializedColumns, table_name), field_name, property_name
+        )
diff --git a/posthog/hogql/transforms/test/__snapshots__/test_in_cohort.ambr b/posthog/hogql/transforms/test/__snapshots__/test_in_cohort.ambr
index cf6c7c1e02e6b..0bccd58cfb853 100644
--- a/posthog/hogql/transforms/test/__snapshots__/test_in_cohort.ambr
+++ b/posthog/hogql/transforms/test/__snapshots__/test_in_cohort.ambr
@@ -42,7 +42,7 @@
   FROM events LEFT JOIN (
   SELECT person_id AS cohort_person_id, 1 AS matched, cohort_id 
   FROM static_cohort_people 
-  WHERE in(cohort_id, [6])) AS __in_cohort ON equals(__in_cohort.cohort_person_id, person_id) 
+  WHERE in(cohort_id, [1, 2, 3, 4, 5 /* ... */])) AS __in_cohort ON equals(__in_cohort.cohort_person_id, person_id) 
   WHERE and(1, equals(__in_cohort.matched, 1)) 
   LIMIT 100
   '''
@@ -66,7 +66,7 @@
   FROM events LEFT JOIN (
   SELECT person_id AS cohort_person_id, 1 AS matched, cohort_id 
   FROM static_cohort_people 
-  WHERE in(cohort_id, [7])) AS __in_cohort ON equals(__in_cohort.cohort_person_id, person_id) 
+  WHERE in(cohort_id, [1, 2, 3, 4, 5 /* ... */])) AS __in_cohort ON equals(__in_cohort.cohort_person_id, person_id) 
   WHERE and(1, equals(__in_cohort.matched, 1)) 
   LIMIT 100
   '''
diff --git a/posthog/hogql/transforms/test/__snapshots__/test_property_types.ambr b/posthog/hogql/transforms/test/__snapshots__/test_property_types.ambr
index c0c2e1a610370..ee5bbaa8881f4 100644
--- a/posthog/hogql/transforms/test/__snapshots__/test_property_types.ambr
+++ b/posthog/hogql/transforms/test/__snapshots__/test_property_types.ambr
@@ -2,7 +2,7 @@
 # name: TestPropertyTypes.test_data_warehouse_person_property_types
   '''
   
-  SELECT persons__extended_properties.string_prop AS string_prop, persons__extended_properties.int_prop AS int_prop, transform(toString(persons__extended_properties.bool_prop), %(hogql_val_8)s, %(hogql_val_9)s, NULL) AS bool_prop 
+  SELECT persons__extended_properties.string_prop AS string_prop, persons__extended_properties.int_prop AS int_prop, toBool(transform(toString(persons__extended_properties.bool_prop), %(hogql_val_8)s, %(hogql_val_9)s, NULL)) AS bool_prop 
   FROM (
   SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, %(hogql_val_0)s), ''), 'null'), '^"|"$', ''), person.version) AS persons___properties___email, person.id AS id 
   FROM person 
@@ -19,7 +19,7 @@
 # name: TestPropertyTypes.test_group_boolean_property_types
   '''
   
-  SELECT ifNull(equals(transform(toString(events__group_0.properties___group_boolean), %(hogql_val_2)s, %(hogql_val_3)s, NULL), 1), 0), ifNull(equals(transform(toString(events__group_0.properties___group_boolean), %(hogql_val_4)s, %(hogql_val_5)s, NULL), 0), 0), isNull(transform(toString(events__group_0.properties___group_boolean), %(hogql_val_6)s, %(hogql_val_7)s, NULL)) 
+  SELECT ifNull(equals(toBool(transform(toString(events__group_0.properties___group_boolean), %(hogql_val_2)s, %(hogql_val_3)s, NULL)), 1), 0), ifNull(equals(toBool(transform(toString(events__group_0.properties___group_boolean), %(hogql_val_4)s, %(hogql_val_5)s, NULL)), 0), 0), isNull(toBool(transform(toString(events__group_0.properties___group_boolean), %(hogql_val_6)s, %(hogql_val_7)s, NULL))) 
   FROM events LEFT JOIN (
   SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, %(hogql_val_0)s), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, %(hogql_val_1)s)) AS properties___group_boolean, groups.group_type_index AS index, groups.group_key AS key 
   FROM groups 
@@ -66,7 +66,7 @@
 # name: TestPropertyTypes.test_resolve_property_types_event
   '''
   
-  SELECT multiply(accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, %(hogql_val_0)s), ''), 'null'), '^"|"$', ''), %(hogql_val_1)s), accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, %(hogql_val_2)s), ''), 'null'), '^"|"$', ''), %(hogql_val_3)s)), transform(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, %(hogql_val_4)s), ''), 'null'), '^"|"$', '')), %(hogql_val_5)s, %(hogql_val_6)s, NULL) AS bool 
+  SELECT multiply(accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, %(hogql_val_0)s), ''), 'null'), '^"|"$', ''), %(hogql_val_1)s), accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, %(hogql_val_2)s), ''), 'null'), '^"|"$', ''), %(hogql_val_3)s)), toBool(transform(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, %(hogql_val_4)s), ''), 'null'), '^"|"$', '')), %(hogql_val_5)s, %(hogql_val_6)s, NULL)) AS bool 
   FROM events 
   WHERE equals(events.team_id, 420) 
   LIMIT 50000
diff --git a/posthog/hogql/transforms/test/test_property_types.py b/posthog/hogql/transforms/test/test_property_types.py
index f27a24b8d7b9f..3fefac96b6b9a 100644
--- a/posthog/hogql/transforms/test/test_property_types.py
+++ b/posthog/hogql/transforms/test/test_property_types.py
@@ -136,7 +136,7 @@ def test_group_boolean_property_types(self):
         )
         assert printed == self.snapshot
         assert (
-            "SELECT ifNull(equals(transform(toString(events__group_0.properties___group_boolean), hogvar, hogvar, NULL), 1), 0), ifNull(equals(transform(toString(events__group_0.properties___group_boolean), hogvar, hogvar, NULL), 0), 0), isNull(transform(toString(events__group_0.properties___group_boolean), hogvar, hogvar, NULL))"
+            "SELECT ifNull(equals(toBool(transform(toString(events__group_0.properties___group_boolean), hogvar, hogvar, NULL)), 1), 0), ifNull(equals(toBool(transform(toString(events__group_0.properties___group_boolean), hogvar, hogvar, NULL)), 0), 0), isNull(toBool(transform(toString(events__group_0.properties___group_boolean), hogvar, hogvar, NULL)))"
             in re.sub(r"%\(hogql_val_\d+\)s", "hogvar", printed)
         )
 
diff --git a/posthog/hogql_queries/actor_strategies.py b/posthog/hogql_queries/actor_strategies.py
index 828365f243db2..acc73559a51e6 100644
--- a/posthog/hogql_queries/actor_strategies.py
+++ b/posthog/hogql_queries/actor_strategies.py
@@ -89,7 +89,7 @@ def get_actors(self, actor_ids, order_by: str = "") -> dict[str, dict]:
         return person_uuid_to_person
 
     def input_columns(self) -> list[str]:
-        return ["person", "id", "created_at", "person.$delete"]
+        return ["person", "id", "person.$delete"]
 
     def filter_conditions(self) -> list[ast.Expr]:
         where_exprs: list[ast.Expr] = []
diff --git a/posthog/hogql_queries/actors_query_runner.py b/posthog/hogql_queries/actors_query_runner.py
index cec4b7019f212..6f15ab96a558c 100644
--- a/posthog/hogql_queries/actors_query_runner.py
+++ b/posthog/hogql_queries/actors_query_runner.py
@@ -3,8 +3,10 @@
 from collections.abc import Sequence, Iterator
 
 from posthog.hogql import ast
-from posthog.hogql.constants import HogQLGlobalSettings
+from posthog.hogql.constants import HogQLGlobalSettings, HogQLQuerySettings
+from posthog.hogql.context import HogQLContext
 from posthog.hogql.parser import parse_expr, parse_order_expr
+from posthog.hogql.printer import print_ast
 from posthog.hogql.property import has_aggregation
 from posthog.hogql.resolver_utils import extract_select_queries
 from posthog.hogql_queries.actor_strategies import ActorStrategy, PersonStrategy, GroupStrategy
@@ -143,7 +145,7 @@ def input_columns(self) -> list[str]:
         return self.strategy.input_columns()
 
     # TODO: Figure out a more sure way of getting the actor id than using the alias or chain name
-    def source_id_column(self, source_query: ast.SelectQuery | ast.SelectSetQuery) -> list[str]:
+    def source_id_column(self, source_query: ast.SelectQuery | ast.SelectSetQuery) -> list[int | str]:
         # Figure out the id column of the source query, first column that has id in the name
         if isinstance(source_query, ast.SelectQuery):
             select = source_query.select
@@ -248,15 +250,49 @@ def to_query(self) -> ast.SelectQuery:
                 order_by = []
 
         with self.timings.measure("select"):
+            select_query = ast.SelectQuery(
+                select=columns,
+                where=where,
+                having=having,
+                group_by=group_by if has_any_aggregation else None,
+                order_by=order_by,
+                settings=HogQLQuerySettings(join_algorithm="auto", optimize_aggregation_in_order=True),
+            )
             if not self.query.source:
-                join_expr = ast.JoinExpr(table=ast.Field(chain=[self.strategy.origin]))
+                select_query.select_from = ast.JoinExpr(table=ast.Field(chain=[self.strategy.origin]))
             else:
                 assert self.source_query_runner is not None  # For type checking
                 source_query = self.source_query_runner.to_actors_query()
-
                 source_id_chain = self.source_id_column(source_query)
                 source_alias = "source"
 
+                # If we aren't joining with the origin, give the source the origin_id
+                for source in (
+                    [source_query] if isinstance(source_query, ast.SelectQuery) else source_query.select_queries()
+                ):
+                    source.select.append(
+                        ast.Alias(alias=self.strategy.origin_id, expr=ast.Field(chain=source_id_chain))
+                    )
+                select_query.select_from = ast.JoinExpr(
+                    table=source_query,
+                    alias=source_alias,
+                )
+
+                try:
+                    print_ast(
+                        select_query,
+                        context=HogQLContext(
+                            team=self.team,
+                            enable_select_queries=True,
+                            timings=self.timings,
+                            modifiers=self.modifiers,
+                        ),
+                        dialect="clickhouse",
+                    )
+                    return select_query
+                except Exception:
+                    pass
+
                 origin = self.strategy.origin
 
                 join_on: ast.Expr = ast.CompareOperation(
@@ -277,7 +313,7 @@ def to_query(self) -> ast.SelectQuery:
                         exprs=[
                             join_on,
                             ast.CompareOperation(
-                                left=ast.Field(chain=[origin, "id"]),
+                                left=ast.Field(chain=[origin, self.strategy.origin_id]),
                                 right=ast.SelectQuery(
                                     select=[ast.Field(chain=[source_alias, *self.source_id_column(source_query)])],
                                     select_from=ast.JoinExpr(table=source_query, alias=source_alias),
@@ -287,7 +323,12 @@ def to_query(self) -> ast.SelectQuery:
                         ]
                     )
 
-                join_expr = ast.JoinExpr(
+                # remove id, which now comes from the origin
+                for source in (
+                    [source_query] if isinstance(source_query, ast.SelectQuery) else source_query.select_queries()
+                ):
+                    source.select.pop()
+                select_query.select_from = ast.JoinExpr(
                     table=source_query,
                     alias=source_alias,
                     next_join=ast.JoinExpr(
@@ -300,14 +341,7 @@ def to_query(self) -> ast.SelectQuery:
                     ),
                 )
 
-        return ast.SelectQuery(
-            select=columns,
-            select_from=join_expr,
-            where=where,
-            having=having,
-            group_by=group_by if has_any_aggregation else None,
-            order_by=order_by,
-        )
+        return select_query
 
     def to_actors_query(self) -> ast.SelectQuery:
         return self.to_query()
diff --git a/posthog/hogql_queries/error_tracking_query_runner.py b/posthog/hogql_queries/error_tracking_query_runner.py
index c6c2231d366b1..88f66050e52e7 100644
--- a/posthog/hogql_queries/error_tracking_query_runner.py
+++ b/posthog/hogql_queries/error_tracking_query_runner.py
@@ -38,7 +38,7 @@ def to_query(self) -> ast.SelectQuery:
             select_from=ast.JoinExpr(table=ast.Field(chain=["events"])),
             where=self.where(),
             order_by=self.order_by,
-            group_by=[ast.Field(chain=["properties", "$exception_issue_id"])],
+            group_by=[ast.Field(chain=["issue_id"])],
         )
 
     def select(self):
@@ -54,7 +54,7 @@ def select(self):
             ),
             ast.Alias(alias="last_seen", expr=ast.Call(name="max", args=[ast.Field(chain=["timestamp"])])),
             ast.Alias(alias="first_seen", expr=ast.Call(name="min", args=[ast.Field(chain=["timestamp"])])),
-            ast.Alias(alias="id", expr=ast.Field(chain=["properties", "$exception_issue_id"])),
+            ast.Alias(alias="id", expr=ast.Field(chain=["issue_id"])),
         ]
 
         if self.query.select:
@@ -71,7 +71,7 @@ def where(self):
             ),
             ast.Call(
                 name="isNotNull",
-                args=[ast.Field(chain=["properties", "$exception_issue_id"])],
+                args=[ast.Field(chain=["issue_id"])],
             ),
             ast.Placeholder(expr=ast.Field(chain=["filters"])),
         ]
@@ -80,7 +80,7 @@ def where(self):
             exprs.append(
                 ast.CompareOperation(
                     op=ast.CompareOperationOp.Eq,
-                    left=ast.Field(chain=["properties", "$exception_issue_id"]),
+                    left=ast.Field(chain=["issue_id"]),
                     right=ast.Constant(value=self.query.issueId),
                 )
             )
@@ -170,7 +170,7 @@ def results(self, columns: list[str], query_results: list):
         for result_dict in mapped_results:
             issue = issues.get(result_dict["id"])
             if issue:
-                results.append(issue | result_dict | {"assignee": self.query.assignee})
+                results.append(issue | result_dict | {"assignee": self.query.assignee, "id": str(result_dict["id"])})
             else:
                 logger.error(
                     "error tracking issue not found",
@@ -210,7 +210,7 @@ def error_tracking_issues(self, ids):
             else queryset
         )
         issues = queryset.values("id", "status", "name", "description")
-        return {str(item["id"]): item for item in issues}
+        return {item["id"]: item for item in issues}
 
 
 def search_tokenizer(query: str) -> list[str]:
diff --git a/posthog/hogql_queries/events_query_runner.py b/posthog/hogql_queries/events_query_runner.py
index cf8435c0bb485..a91e92d38c564 100644
--- a/posthog/hogql_queries/events_query_runner.py
+++ b/posthog/hogql_queries/events_query_runner.py
@@ -101,7 +101,7 @@ def to_query(self) -> ast.SelectQuery:
                 if self.query.actionId:
                     with self.timings.measure("action_id"):
                         try:
-                            action = Action.objects.get(pk=self.query.actionId, team_id=self.team.pk)
+                            action = Action.objects.get(pk=self.query.actionId, team__project_id=self.team.project_id)
                         except Action.DoesNotExist:
                             raise Exception("Action does not exist")
                         if not action.steps:
diff --git a/posthog/hogql_queries/experiments/experiment_funnels_query_runner.py b/posthog/hogql_queries/experiments/experiment_funnels_query_runner.py
index 69e12f49bbd13..d9d874d7b6e6b 100644
--- a/posthog/hogql_queries/experiments/experiment_funnels_query_runner.py
+++ b/posthog/hogql_queries/experiments/experiment_funnels_query_runner.py
@@ -20,7 +20,7 @@
     FunnelsFilter,
     FunnelsQuery,
     FunnelsQueryResponse,
-    InsightDateRange,
+    DateRange,
     BreakdownFilter,
 )
 from typing import Optional, Any, cast
@@ -105,7 +105,7 @@ def _prepare_funnel_query(self) -> FunnelsQuery:
             start_date = self.experiment.start_date
             end_date = self.experiment.end_date
 
-        prepared_funnels_query.dateRange = InsightDateRange(
+        prepared_funnels_query.dateRange = DateRange(
             date_from=start_date.isoformat() if start_date else None,
             date_to=end_date.isoformat() if end_date else None,
             explicitDate=True,
diff --git a/posthog/hogql_queries/experiments/experiment_trends_query_runner.py b/posthog/hogql_queries/experiments/experiment_trends_query_runner.py
index 06619c4dfeee1..56c089d27cb9d 100644
--- a/posthog/hogql_queries/experiments/experiment_trends_query_runner.py
+++ b/posthog/hogql_queries/experiments/experiment_trends_query_runner.py
@@ -9,6 +9,11 @@
     calculate_credible_intervals,
     calculate_probabilities,
 )
+from posthog.hogql_queries.experiments.trends_statistics_v2 import (
+    are_results_significant_v2,
+    calculate_credible_intervals_v2,
+    calculate_probabilities_v2,
+)
 from posthog.hogql_queries.insights.trends.trends_query_runner import TrendsQueryRunner
 from posthog.hogql_queries.query_runner import QueryRunner
 from posthog.models.experiment import Experiment
@@ -27,7 +32,7 @@
     ExperimentTrendsQuery,
     ExperimentTrendsQueryResponse,
     ExperimentVariantTrendsBaseStats,
-    InsightDateRange,
+    DateRange,
     PropertyMathType,
     PropertyOperator,
     TrendsFilter,
@@ -56,6 +61,8 @@ def __init__(self, *args, **kwargs):
             self.variants.append(f"holdout-{self.experiment.holdout.id}")
         self.breakdown_key = f"$feature/{self.feature_flag.key}"
 
+        self.stats_version = self.query.stats_version or 1
+
         self.prepared_count_query = self._prepare_count_query()
         self.prepared_exposure_query = self._prepare_exposure_query()
 
@@ -73,9 +80,9 @@ def _uses_math_aggregation_by_user_or_property_value(self, query: TrendsQuery):
             math_keys.remove("sum")
         return any(entity.math in math_keys for entity in query.series)
 
-    def _get_insight_date_range(self) -> InsightDateRange:
+    def _get_date_range(self) -> DateRange:
         """
-        Returns an InsightDateRange object based on the experiment's start and end dates,
+        Returns an DateRange object based on the experiment's start and end dates,
         adjusted for the team's timezone if applicable.
         """
         if self.team.timezone:
@@ -86,7 +93,7 @@ def _get_insight_date_range(self) -> InsightDateRange:
             start_date = self.experiment.start_date
             end_date = self.experiment.end_date
 
-        return InsightDateRange(
+        return DateRange(
             date_from=start_date.isoformat() if start_date else None,
             date_to=end_date.isoformat() if end_date else None,
             explicitDate=True,
@@ -126,7 +133,7 @@ def _prepare_count_query(self) -> TrendsQuery:
             prepared_count_query.series[0].math = None
 
         prepared_count_query.trendsFilter = TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH_CUMULATIVE)
-        prepared_count_query.dateRange = self._get_insight_date_range()
+        prepared_count_query.dateRange = self._get_date_range()
         if self._is_data_warehouse_query(prepared_count_query):
             prepared_count_query.breakdownFilter = self._get_data_warehouse_breakdown_filter()
             prepared_count_query.properties = [
@@ -171,38 +178,58 @@ def _prepare_exposure_query(self) -> TrendsQuery:
 
         # 1. If math aggregation is used, we construct an implicit exposure query: unique users for the count event
         uses_math_aggregation = self._uses_math_aggregation_by_user_or_property_value(self.query.count_query)
+        prepared_count_query = TrendsQuery(**self.query.count_query.model_dump())
 
         if uses_math_aggregation:
-            prepared_exposure_query = TrendsQuery(**self.query.count_query.model_dump())
-            count_event = self.query.count_query.series[0]
-
-            if hasattr(count_event, "event"):
-                prepared_exposure_query.dateRange = self._get_insight_date_range()
-                prepared_exposure_query.breakdownFilter = self._get_event_breakdown_filter()
-                prepared_exposure_query.trendsFilter = TrendsFilter(
-                    display=ChartDisplayType.ACTIONS_LINE_GRAPH_CUMULATIVE
-                )
-                prepared_exposure_query.series = [
-                    EventsNode(
-                        event=count_event.event,
-                        math=BaseMathType.DAU,
-                    )
-                ]
+            prepared_exposure_query = prepared_count_query
+            prepared_exposure_query.dateRange = self._get_date_range()
+            prepared_exposure_query.trendsFilter = TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH_CUMULATIVE)
+
+            # For a data warehouse query, we can use the unique users for the series
+            if self._is_data_warehouse_query(prepared_exposure_query):
+                prepared_exposure_query.breakdownFilter = self._get_data_warehouse_breakdown_filter()
+                prepared_exposure_query.series[0].math = BaseMathType.DAU
+                prepared_exposure_query.series[0].math_property = None
+                prepared_exposure_query.series[0].math_property_type = None
                 prepared_exposure_query.properties = [
-                    EventPropertyFilter(
-                        key=self.breakdown_key,
+                    DataWarehousePropertyFilter(
+                        key="events.event",
+                        value="$feature_flag_called",
+                        operator=PropertyOperator.EXACT,
+                        type="data_warehouse",
+                    ),
+                    DataWarehousePropertyFilter(
+                        key=f"events.properties.{self.breakdown_key}",
                         value=self.variants,
                         operator=PropertyOperator.EXACT,
-                        type="event",
-                    )
+                        type="data_warehouse",
+                    ),
                 ]
             else:
-                raise ValueError("Expected first series item to have an 'event' attribute")
+                count_event = self.query.count_query.series[0]
+                if hasattr(count_event, "event"):
+                    prepared_exposure_query.breakdownFilter = self._get_event_breakdown_filter()
+                    prepared_exposure_query.series = [
+                        EventsNode(
+                            event=count_event.event,
+                            math=BaseMathType.DAU,
+                        )
+                    ]
+                    prepared_exposure_query.properties = [
+                        EventPropertyFilter(
+                            key=self.breakdown_key,
+                            value=self.variants,
+                            operator=PropertyOperator.EXACT,
+                            type="event",
+                        )
+                    ]
+                else:
+                    raise ValueError("Expected first series item to have an 'event' attribute")
 
         # 2. Otherwise, if an exposure query is provided, we use it as is, adapting the date range and breakdown
-        elif self.query.exposure_query:
+        elif self.query.exposure_query and not self._is_data_warehouse_query(prepared_count_query):
             prepared_exposure_query = TrendsQuery(**self.query.exposure_query.model_dump())
-            prepared_exposure_query.dateRange = self._get_insight_date_range()
+            prepared_exposure_query.dateRange = self._get_date_range()
             prepared_exposure_query.trendsFilter = TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH_CUMULATIVE)
             prepared_exposure_query.breakdownFilter = self._get_event_breakdown_filter()
             prepared_exposure_query.properties = [
@@ -216,7 +243,7 @@ def _prepare_exposure_query(self) -> TrendsQuery:
         # 3. Otherwise, we construct a default exposure query: unique users for the $feature_flag_called event
         else:
             prepared_exposure_query = TrendsQuery(
-                dateRange=self._get_insight_date_range(),
+                dateRange=self._get_date_range(),
                 trendsFilter=TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH_CUMULATIVE),
                 breakdownFilter=BreakdownFilter(
                     breakdown="$feature_flag_response",
@@ -288,9 +315,14 @@ def run(query_runner: TrendsQueryRunner, result_key: str, is_parallel: bool):
 
         # Statistical analysis
         control_variant, test_variants = self._get_variants_with_base_stats(count_result, exposure_result)
-        probabilities = calculate_probabilities(control_variant, test_variants)
-        significance_code, p_value = are_results_significant(control_variant, test_variants, probabilities)
-        credible_intervals = calculate_credible_intervals([control_variant, *test_variants])
+        if self.stats_version == 2:
+            probabilities = calculate_probabilities_v2(control_variant, test_variants)
+            significance_code, p_value = are_results_significant_v2(control_variant, test_variants, probabilities)
+            credible_intervals = calculate_credible_intervals_v2([control_variant, *test_variants])
+        else:
+            probabilities = calculate_probabilities(control_variant, test_variants)
+            significance_code, p_value = are_results_significant(control_variant, test_variants, probabilities)
+            credible_intervals = calculate_credible_intervals([control_variant, *test_variants])
 
         return ExperimentTrendsQueryResponse(
             kind="ExperimentTrendsQuery",
@@ -304,6 +336,7 @@ def run(query_runner: TrendsQueryRunner, result_key: str, is_parallel: bool):
             },
             significant=significance_code == ExperimentSignificanceCode.SIGNIFICANT,
             significance_code=significance_code,
+            stats_version=self.stats_version,
             p_value=p_value,
             credible_intervals=credible_intervals,
         )
diff --git a/posthog/hogql_queries/experiments/test/test_experiment_funnels_query_runner.py b/posthog/hogql_queries/experiments/test/test_experiment_funnels_query_runner.py
index 98599790f3865..3f3127fcb1b55 100644
--- a/posthog/hogql_queries/experiments/test/test_experiment_funnels_query_runner.py
+++ b/posthog/hogql_queries/experiments/test/test_experiment_funnels_query_runner.py
@@ -16,6 +16,7 @@
 from posthog.constants import ExperimentNoResultsErrorKeys
 import json
 from posthog.test.test_journeys import journeys_for
+from flaky import flaky
 
 
 class TestExperimentFunnelsQueryRunner(ClickhouseTestMixin, APIBaseTest):
@@ -128,6 +129,7 @@ def test_query_runner(self):
         self.assertIn("control", result.credible_intervals)
         self.assertIn("test", result.credible_intervals)
 
+    @flaky(max_runs=10, min_passes=1)
     @freeze_time("2020-01-01T12:00:00Z")
     def test_query_runner_standard_flow(self):
         feature_flag = self.create_feature_flag()
diff --git a/posthog/hogql_queries/experiments/test/test_experiment_trends_query_runner.py b/posthog/hogql_queries/experiments/test/test_experiment_trends_query_runner.py
index 8837bfeab8607..9ed6636bc2324 100644
--- a/posthog/hogql_queries/experiments/test/test_experiment_trends_query_runner.py
+++ b/posthog/hogql_queries/experiments/test/test_experiment_trends_query_runner.py
@@ -17,7 +17,7 @@
     OBJECT_STORAGE_SECRET_ACCESS_KEY,
     XDIST_SUFFIX,
 )
-from posthog.test.base import APIBaseTest, ClickhouseTestMixin, _create_event, flush_persons_and_events
+from posthog.test.base import APIBaseTest, ClickhouseTestMixin, _create_event, _create_person, flush_persons_and_events
 from freezegun import freeze_time
 from typing import cast
 from django.utils import timezone
@@ -29,12 +29,14 @@
 from pyarrow import parquet as pq
 import pyarrow as pa
 import json
+from flaky import flaky
 
 from boto3 import resource
 from botocore.config import Config
 from posthog.warehouse.models.credential import DataWarehouseCredential
 from posthog.warehouse.models.join import DataWarehouseJoin
 from posthog.warehouse.models.table import DataWarehouseTable
+from posthog.hogql.query import execute_hogql_query
 
 TEST_BUCKET = "test_storage_bucket-posthog.hogql.datawarehouse.trendquery" + XDIST_SUFFIX
 
@@ -181,6 +183,80 @@ def create_data_warehouse_table_with_payments(self):
         )
         return table_name
 
+    def create_data_warehouse_table_with_usage(self):
+        if not OBJECT_STORAGE_ACCESS_KEY_ID or not OBJECT_STORAGE_SECRET_ACCESS_KEY:
+            raise Exception("Missing vars")
+
+        fs = s3fs.S3FileSystem(
+            client_kwargs={
+                "region_name": "us-east-1",
+                "endpoint_url": OBJECT_STORAGE_ENDPOINT,
+                "aws_access_key_id": OBJECT_STORAGE_ACCESS_KEY_ID,
+                "aws_secret_access_key": OBJECT_STORAGE_SECRET_ACCESS_KEY,
+            },
+        )
+
+        path_to_s3_object = "s3://" + OBJECT_STORAGE_BUCKET + f"/{TEST_BUCKET}"
+
+        id = pa.array(["1", "2", "3", "4", "5", "6"])
+        date = pa.array(["2023-01-01", "2023-01-02", "2023-01-03", "2023-01-04", "2023-01-06", "2023-01-07"])
+        user_id = pa.array(
+            ["user_control_0", "user_test_1", "user_test_2", "internal_test_1", "user_test_3", "user_extra"]
+        )
+        usage = pa.array([1000, 500, 750, 100000, 800, 900])
+        names = ["id", "ds", "userid", "usage"]
+
+        pq.write_to_dataset(
+            pa.Table.from_arrays([id, date, user_id, usage], names=names),
+            path_to_s3_object,
+            filesystem=fs,
+            use_dictionary=True,
+            compression="snappy",
+            version="2.0",
+        )
+
+        table_name = "usage"
+
+        credential = DataWarehouseCredential.objects.create(
+            access_key=OBJECT_STORAGE_ACCESS_KEY_ID,
+            access_secret=OBJECT_STORAGE_SECRET_ACCESS_KEY,
+            team=self.team,
+        )
+
+        DataWarehouseTable.objects.create(
+            name=table_name,
+            url_pattern=f"http://host.docker.internal:19000/{OBJECT_STORAGE_BUCKET}/{TEST_BUCKET}/*.parquet",
+            format=DataWarehouseTable.TableFormat.Parquet,
+            team=self.team,
+            columns={
+                "id": "String",
+                "ds": "Date",
+                "userid": "String",
+                "usage": "Int64",
+            },
+            credential=credential,
+        )
+
+        DataWarehouseJoin.objects.create(
+            team=self.team,
+            source_table_name=table_name,
+            source_table_key="userid",
+            joining_table_name="events",
+            joining_table_key="properties.$user_id",
+            field_name="events",
+            configuration={"experiments_optimized": True, "experiments_timestamp_key": "ds"},
+        )
+
+        DataWarehouseJoin.objects.create(
+            team=self.team,
+            source_table_name=table_name,
+            source_table_key="userid",
+            joining_table_name="persons",
+            joining_table_key="properties.$user_id",
+            field_name="person",
+        )
+        return table_name
+
     @freeze_time("2020-01-01T12:00:00Z")
     def test_query_runner(self):
         feature_flag = self.create_feature_flag()
@@ -217,7 +293,11 @@ def test_query_runner(self):
                     team=self.team,
                     event="$feature_flag_called",
                     distinct_id=f"user_{variant}_{i}",
-                    properties={feature_flag_property: variant},
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                    },
                 )
 
         flush_persons_and_events()
@@ -465,7 +545,11 @@ def test_query_runner_with_holdout(self):
                     team=self.team,
                     event="$feature_flag_called",
                     distinct_id=f"user_{variant}_{i}",
-                    properties={feature_flag_property: variant},
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                    },
                 )
 
         flush_persons_and_events()
@@ -488,7 +572,7 @@ def test_query_runner_with_holdout(self):
         self.assertEqual(test_result.absolute_exposure, 9)
         self.assertEqual(holdout_result.absolute_exposure, 4)
 
-    def test_query_runner_with_data_warehouse_series(self):
+    def test_query_runner_with_data_warehouse_series_total_count(self):
         table_name = self.create_data_warehouse_table_with_payments()
 
         feature_flag = self.create_feature_flag()
@@ -508,6 +592,7 @@ def test_query_runner_with_data_warehouse_series(self):
                     id_field="id",
                     table_name=table_name,
                     timestamp_field="dw_timestamp",
+                    math="total",
                 )
             ]
         )
@@ -530,7 +615,11 @@ def test_query_runner_with_data_warehouse_series(self):
                     team=self.team,
                     event="$feature_flag_called",
                     distinct_id=f"user_{variant}_{i}",
-                    properties={feature_flag_property: variant},
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                    },
                     timestamp=datetime(2023, 1, i + 1),
                 )
 
@@ -544,7 +633,11 @@ def test_query_runner_with_data_warehouse_series(self):
             team=self.team,
             event="$feature_flag_called",
             distinct_id="user_test_3",
-            properties={feature_flag_property: "control"},
+            properties={
+                feature_flag_property: "control",
+                "$feature_flag_response": "control",
+                "$feature_flag": feature_flag.key,
+            },
             timestamp=datetime(2023, 1, 3),
         )
         _create_event(
@@ -558,7 +651,11 @@ def test_query_runner_with_data_warehouse_series(self):
             team=self.team,
             event="$feature_flag_called",
             distinct_id="user_test_3",
-            properties={feature_flag_property: "control"},
+            properties={
+                feature_flag_property: "control",
+                "$feature_flag_response": "control",
+                "$feature_flag": feature_flag.key,
+            },
             timestamp=datetime(2023, 1, 9),
         )
 
@@ -582,9 +679,8 @@ def test_query_runner_with_data_warehouse_series(self):
         self.assertEqual(control_result.absolute_exposure, 9)
         self.assertEqual(test_result.absolute_exposure, 9)
 
-    def test_query_runner_with_invalid_data_warehouse_table_name(self):
-        # parquet file isn't created, so we'll get an error
-        table_name = "invalid_table_name"
+    def test_query_runner_with_data_warehouse_series_avg_amount(self):
+        table_name = self.create_data_warehouse_table_with_payments()
 
         feature_flag = self.create_feature_flag()
         experiment = self.create_experiment(
@@ -593,6 +689,8 @@ def test_query_runner_with_invalid_data_warehouse_table_name(self):
             end_date=datetime(2023, 1, 10),
         )
 
+        feature_flag_property = f"$feature/{feature_flag.key}"
+
         count_query = TrendsQuery(
             series=[
                 DataWarehouseNode(
@@ -601,6 +699,9 @@ def test_query_runner_with_invalid_data_warehouse_table_name(self):
                     id_field="id",
                     table_name=table_name,
                     timestamp_field="dw_timestamp",
+                    math="avg",
+                    math_property="amount",
+                    math_property_type="data_warehouse_properties",
                 )
             ]
         )
@@ -616,48 +717,129 @@ def test_query_runner_with_invalid_data_warehouse_table_name(self):
         experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
         experiment.save()
 
+        # Populate exposure events
+        for variant, count in [("control", 7), ("test", 9)]:
+            for i in range(count):
+                _create_event(
+                    team=self.team,
+                    event="$feature_flag_called",
+                    distinct_id=f"user_{variant}_{i}",
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                    },
+                    timestamp=datetime(2023, 1, i + 1),
+                )
+
+        # "user_test_3" first exposure (feature_flag_property="control") is on 2023-01-03
+        # "user_test_3" relevant exposure (feature_flag_property="test") is on 2023-01-04
+        # "user_test_3" other event (feature_flag_property="control" is on 2023-01-05
+        # "user_test_3" purchase is on 2023-01-06
+        # "user_test_3" second exposure (feature_flag_property="control") is on 2023-01-09
+        # "user_test_3" should fall into the "test" variant, not the "control" variant
+        _create_event(
+            team=self.team,
+            event="$feature_flag_called",
+            distinct_id="user_test_3",
+            properties={
+                "$feature_flag_response": "control",
+                feature_flag_property: "control",
+                "$feature_flag": feature_flag.key,
+            },
+            timestamp=datetime(2023, 1, 3),
+        )
+        _create_event(
+            team=self.team,
+            event="Some other event",
+            distinct_id="user_test_3",
+            properties={
+                "$feature_flag_response": "control",
+                feature_flag_property: "control",
+                "$feature_flag": feature_flag.key,
+            },
+            timestamp=datetime(2023, 1, 5),
+        )
+        _create_event(
+            team=self.team,
+            event="$feature_flag_called",
+            distinct_id="user_test_3",
+            properties={
+                "$feature_flag_response": "control",
+                feature_flag_property: "control",
+                "$feature_flag": feature_flag.key,
+            },
+            timestamp=datetime(2023, 1, 9),
+        )
+
+        flush_persons_and_events()
+
         query_runner = ExperimentTrendsQueryRunner(
             query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
         )
         with freeze_time("2023-01-07"):
-            with self.assertRaises(KeyError) as context:
-                query_runner.calculate()
+            result = query_runner.calculate()
 
-        self.assertEqual(str(context.exception), "'invalid_table_name'")
+        trend_result = cast(ExperimentTrendsQueryResponse, result)
 
-    @freeze_time("2020-01-01T12:00:00Z")
-    def test_query_runner_with_avg_math(self):
-        feature_flag = self.create_feature_flag()
-        experiment = self.create_experiment(feature_flag=feature_flag)
+        self.assertEqual(len(result.variants), 2)
 
-        count_query = TrendsQuery(series=[EventsNode(event="$pageview", math="avg")])
-        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+        control_result = next(variant for variant in trend_result.variants if variant.key == "control")
+        test_result = next(variant for variant in trend_result.variants if variant.key == "test")
 
-        experiment_query = ExperimentTrendsQuery(
-            experiment_id=experiment.id,
-            kind="ExperimentTrendsQuery",
-            count_query=count_query,
-            exposure_query=exposure_query,
-        )
+        control_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "control")
+        test_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "test")
 
-        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
-        experiment.save()
+        self.assertEqual(control_result.count, 100)
+        self.assertEqual(test_result.count, 205)
+        self.assertEqual(control_result.absolute_exposure, 1)
+        self.assertEqual(test_result.absolute_exposure, 3)
 
-        query_runner = ExperimentTrendsQueryRunner(
-            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        self.assertEqual(
+            control_insight["data"],
+            [100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0],
+        )
+        self.assertEqual(
+            test_insight["data"],
+            [0.0, 50.0, 125.0, 125.0, 125.0, 205.0, 205.0, 205.0, 205.0, 205.0],
         )
 
-        prepared_count_query = query_runner.prepared_count_query
-        self.assertEqual(prepared_count_query.series[0].math, "sum")
+    def test_query_runner_with_data_warehouse_series_no_end_date_and_nested_id(self):
+        table_name = self.create_data_warehouse_table_with_usage()
 
-    @freeze_time("2020-01-01T12:00:00Z")
-    def test_query_runner_standard_flow(self):
         feature_flag = self.create_feature_flag()
-        experiment = self.create_experiment(feature_flag=feature_flag)
+        experiment = self.create_experiment(
+            feature_flag=feature_flag,
+            start_date=datetime(2023, 1, 1),
+        )
 
-        ff_property = f"$feature/{feature_flag.key}"
-        count_query = TrendsQuery(series=[EventsNode(event="$pageview")])
-        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+        feature_flag_property = f"$feature/{feature_flag.key}"
+
+        self.team.test_account_filters = [
+            {
+                "key": "email",
+                "value": "@posthog.com",
+                "operator": "not_icontains",
+                "type": "person",
+            }
+        ]
+        self.team.save()
+        count_query = TrendsQuery(
+            series=[
+                DataWarehouseNode(
+                    id=table_name,
+                    distinct_id_field="userid",
+                    id_field="id",
+                    table_name=table_name,
+                    timestamp_field="ds",
+                    math="avg",
+                    math_property="usage",
+                    math_property_type="data_warehouse_properties",
+                )
+            ],
+            filterTestAccounts=True,
+        )
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")], filterTestAccounts=True)
 
         experiment_query = ExperimentTrendsQuery(
             experiment_id=experiment.id,
@@ -669,38 +851,82 @@ def test_query_runner_standard_flow(self):
         experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
         experiment.save()
 
-        journeys_for(
-            {
-                "user_control_1": [
-                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "control"}},
-                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "control"}},
-                    {
-                        "event": "$feature_flag_called",
-                        "timestamp": "2020-01-02",
-                        "properties": {ff_property: "control"},
-                    },
-                ],
-                "user_control_2": [
-                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "control"}},
-                    {
-                        "event": "$feature_flag_called",
-                        "timestamp": "2020-01-02",
-                        "properties": {ff_property: "control"},
+        # Populate exposure events
+        for variant, count in [("control", 7), ("test", 9)]:
+            for i in range(count):
+                _create_event(
+                    team=self.team,
+                    event="$feature_flag_called",
+                    distinct_id=f"distinct_{variant}_{i}",
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                        "$user_id": f"user_{variant}_{i}",
                     },
-                ],
-                "user_test_1": [
-                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
-                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "test"}},
-                    {"event": "$pageview", "timestamp": "2020-01-04", "properties": {ff_property: "test"}},
-                    {"event": "$feature_flag_called", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
-                ],
-                "user_test_2": [
-                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
-                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "test"}},
-                    {"event": "$feature_flag_called", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
-                ],
+                    timestamp=datetime(2023, 1, i + 1),
+                )
+
+        _create_person(
+            team=self.team,
+            distinct_ids=["internal_test_1"],
+            properties={"email": "internal_test_1@posthog.com", "$user_id": "internal_test_1"},
+        )
+
+        _create_event(
+            team=self.team,
+            event="$feature_flag_called",
+            distinct_id="internal_test_1",
+            properties={
+                feature_flag_property: "test",
+                "$feature_flag_response": "test",
+                "$feature_flag": feature_flag.key,
+                "$user_id": "internal_test_1",
             },
-            self.team,
+            timestamp=datetime(2023, 1, 3),
+        )
+
+        # "user_test_3" first exposure (feature_flag_property="control") is on 2023-01-03
+        # "user_test_3" relevant exposure (feature_flag_property="test") is on 2023-01-04
+        # "user_test_3" other event (feature_flag_property="control" is on 2023-01-05
+        # "user_test_3" purchase is on 2023-01-06
+        # "user_test_3" second exposure (feature_flag_property="control") is on 2023-01-09
+        # "user_test_3" should fall into the "test" variant, not the "control" variant
+        _create_event(
+            team=self.team,
+            event="$feature_flag_called",
+            distinct_id="distinct_test_3",
+            properties={
+                "$feature_flag_response": "control",
+                feature_flag_property: "control",
+                "$feature_flag": feature_flag.key,
+                "$user_id": "user_test_3",
+            },
+            timestamp=datetime(2023, 1, 3),
+        )
+        _create_event(
+            team=self.team,
+            event="Some other event",
+            distinct_id="distinct_test_3",
+            properties={
+                "$feature_flag_response": "control",
+                feature_flag_property: "control",
+                "$feature_flag": feature_flag.key,
+                "$user_id": "user_test_3",
+            },
+            timestamp=datetime(2023, 1, 5),
+        )
+        _create_event(
+            team=self.team,
+            event="$feature_flag_called",
+            distinct_id="distinct_test_3",
+            properties={
+                "$feature_flag_response": "control",
+                feature_flag_property: "control",
+                "$feature_flag": feature_flag.key,
+                "$user_id": "user_test_3",
+            },
+            timestamp=datetime(2023, 1, 9),
         )
 
         flush_persons_and_events()
@@ -708,35 +934,462 @@ def test_query_runner_standard_flow(self):
         query_runner = ExperimentTrendsQueryRunner(
             query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
         )
-        result = query_runner.calculate()
-
-        self.assertEqual(len(result.variants), 2)
-        for variant in result.variants:
-            self.assertIn(variant.key, ["control", "test"])
+        with freeze_time("2023-01-07"):
+            # Build and execute the query to get the ClickHouse SQL
+            queries = query_runner.count_query_runner.to_queries()
+            response = execute_hogql_query(
+                query_type="TrendsQuery",
+                query=queries[0],
+                team=query_runner.count_query_runner.team,
+                modifiers=query_runner.count_query_runner.modifiers,
+                limit_context=query_runner.count_query_runner.limit_context,
+            )
+
+            # Assert the expected join condition in the clickhouse SQL
+            expected_join_condition = f"and(equals(events.team_id, {query_runner.count_query_runner.team.id}), equals(event, %(hogql_val_12)s), greaterOrEquals(timestamp, assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_13)s, 6, %(hogql_val_14)s))), lessOrEquals(timestamp, assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_15)s, 6, %(hogql_val_16)s))))) AS e__events ON"
+            self.assertIn(
+                expected_join_condition,
+                str(response.clickhouse),
+                "Please check to make sure the timestamp statements are included in the ASOF LEFT JOIN select statement. This may also fail if the placeholder numbers have changed.",
+            )
 
-        control_variant = next(v for v in result.variants if v.key == "control")
-        test_variant = next(v for v in result.variants if v.key == "test")
+            result = query_runner.calculate()
 
-        self.assertEqual(control_variant.count, 3)
-        self.assertEqual(test_variant.count, 5)
-        self.assertEqual(control_variant.absolute_exposure, 2)
-        self.assertEqual(test_variant.absolute_exposure, 2)
+        trend_result = cast(ExperimentTrendsQueryResponse, result)
 
-        self.assertAlmostEqual(result.credible_intervals["control"][0], 0.5449, places=3)
-        self.assertAlmostEqual(result.credible_intervals["control"][1], 4.3836, places=3)
-        self.assertAlmostEqual(result.credible_intervals["test"][0], 1.1009, places=3)
-        self.assertAlmostEqual(result.credible_intervals["test"][1], 5.8342, places=3)
+        self.assertEqual(len(result.variants), 2)
 
-        self.assertAlmostEqual(result.p_value, 1.0, places=3)
+        control_result = next(variant for variant in trend_result.variants if variant.key == "control")
+        test_result = next(variant for variant in trend_result.variants if variant.key == "test")
 
-        self.assertAlmostEqual(result.probability["control"], 0.2549, places=2)
-        self.assertAlmostEqual(result.probability["test"], 0.7453, places=2)
+        control_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "control")
+        test_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "test")
 
-        self.assertEqual(result.significance_code, ExperimentSignificanceCode.NOT_ENOUGH_EXPOSURE)
+        self.assertEqual(control_result.count, 1000)
+        self.assertEqual(test_result.count, 2050)
+        self.assertEqual(control_result.absolute_exposure, 1)
+        self.assertEqual(test_result.absolute_exposure, 3)
 
-        self.assertFalse(result.significant)
+        self.assertEqual(
+            control_insight["data"][:10],
+            [1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0],
+        )
+        self.assertEqual(
+            test_insight["data"][:10],
+            [0.0, 500.0, 1250.0, 1250.0, 1250.0, 2050.0, 2050.0, 2050.0, 2050.0, 2050.0],
+        )
 
-        self.assertEqual(len(result.variants), 2)
+        # Run the query again with filter_test_accounts=False
+        # as a point of comparison to above
+        count_query = TrendsQuery(
+            series=[
+                DataWarehouseNode(
+                    id=table_name,
+                    distinct_id_field="userid",
+                    id_field="id",
+                    table_name=table_name,
+                    timestamp_field="ds",
+                    math="avg",
+                    math_property="usage",
+                    math_property_type="data_warehouse_properties",
+                )
+            ],
+            filterTestAccounts=False,
+        )
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")], filterTestAccounts=False)
+
+        experiment_query = ExperimentTrendsQuery(
+            experiment_id=experiment.id,
+            kind="ExperimentTrendsQuery",
+            count_query=count_query,
+            exposure_query=exposure_query,
+        )
+
+        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
+        experiment.save()
+
+        query_runner = ExperimentTrendsQueryRunner(
+            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        )
+        with freeze_time("2023-01-07"):
+            result = query_runner.calculate()
+
+        trend_result = cast(ExperimentTrendsQueryResponse, result)
+
+        self.assertEqual(len(result.variants), 2)
+
+        control_result = next(variant for variant in trend_result.variants if variant.key == "control")
+        test_result = next(variant for variant in trend_result.variants if variant.key == "test")
+
+        control_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "control")
+        test_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "test")
+
+        self.assertEqual(control_result.count, 1000)
+        self.assertEqual(test_result.count, 102050)
+        self.assertEqual(control_result.absolute_exposure, 1)
+        self.assertEqual(test_result.absolute_exposure, 4)
+
+        self.assertEqual(
+            control_insight["data"][:10],
+            [1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0],
+        )
+        self.assertEqual(
+            test_insight["data"][:10],
+            [0.0, 500.0, 1250.0, 101250.0, 101250.0, 102050.0, 102050.0, 102050.0, 102050.0, 102050.0],
+        )
+
+    def test_query_runner_with_data_warehouse_series_expected_query(self):
+        table_name = self.create_data_warehouse_table_with_payments()
+
+        feature_flag = self.create_feature_flag()
+        experiment = self.create_experiment(
+            feature_flag=feature_flag,
+            start_date=datetime(2023, 1, 1),
+            end_date=datetime(2023, 1, 10),
+        )
+
+        feature_flag_property = f"$feature/{feature_flag.key}"
+
+        count_query = TrendsQuery(
+            series=[
+                DataWarehouseNode(
+                    id=table_name,
+                    distinct_id_field="dw_distinct_id",
+                    id_field="id",
+                    table_name=table_name,
+                    timestamp_field="dw_timestamp",
+                    math="total",
+                )
+            ]
+        )
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+
+        experiment_query = ExperimentTrendsQuery(
+            experiment_id=experiment.id,
+            kind="ExperimentTrendsQuery",
+            count_query=count_query,
+            exposure_query=exposure_query,
+        )
+
+        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
+        experiment.save()
+
+        # Populate exposure events
+        for variant, count in [("control", 7), ("test", 9)]:
+            for i in range(count):
+                _create_event(
+                    team=self.team,
+                    event="$feature_flag_called",
+                    distinct_id=f"user_{variant}_{i}",
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                    },
+                    timestamp=datetime(2023, 1, i + 1),
+                )
+
+        flush_persons_and_events()
+
+        query_runner = ExperimentTrendsQueryRunner(
+            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        )
+        with freeze_time("2023-01-07"):
+            # Build and execute the query to get the ClickHouse SQL
+            queries = query_runner.count_query_runner.to_queries()
+            response = execute_hogql_query(
+                query_type="TrendsQuery",
+                query=queries[0],
+                team=query_runner.count_query_runner.team,
+                modifiers=query_runner.count_query_runner.modifiers,
+                limit_context=query_runner.count_query_runner.limit_context,
+            )
+
+            # Assert the expected join condition in the clickhouse SQL
+            expected_join_condition = f"and(equals(events.team_id, {query_runner.count_query_runner.team.id}), equals(event, %(hogql_val_7)s), greaterOrEquals(timestamp, assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_8)s, 6, %(hogql_val_9)s))), lessOrEquals(timestamp, assumeNotNull(parseDateTime64BestEffortOrNull(%(hogql_val_10)s, 6, %(hogql_val_11)s))))) AS e__events ON"
+            self.assertIn(
+                expected_join_condition,
+                str(response.clickhouse),
+                "Please check to make sure the timestamp statements are included in the ASOF LEFT JOIN select statement. This may also fail if the placeholder numbers have changed.",
+            )
+
+            result = query_runner.calculate()
+
+        trend_result = cast(ExperimentTrendsQueryResponse, result)
+
+        self.assertEqual(len(result.variants), 2)
+
+        control_result = next(variant for variant in trend_result.variants if variant.key == "control")
+        test_result = next(variant for variant in trend_result.variants if variant.key == "test")
+
+        self.assertEqual(control_result.count, 1)
+        self.assertEqual(test_result.count, 3)
+        self.assertEqual(control_result.absolute_exposure, 7)
+        self.assertEqual(test_result.absolute_exposure, 9)
+
+    def test_query_runner_with_invalid_data_warehouse_table_name(self):
+        # parquet file isn't created, so we'll get an error
+        table_name = "invalid_table_name"
+
+        feature_flag = self.create_feature_flag()
+        experiment = self.create_experiment(
+            feature_flag=feature_flag,
+            start_date=datetime(2023, 1, 1),
+            end_date=datetime(2023, 1, 10),
+        )
+
+        count_query = TrendsQuery(
+            series=[
+                DataWarehouseNode(
+                    id=table_name,
+                    distinct_id_field="dw_distinct_id",
+                    id_field="id",
+                    table_name=table_name,
+                    timestamp_field="dw_timestamp",
+                )
+            ]
+        )
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+
+        experiment_query = ExperimentTrendsQuery(
+            experiment_id=experiment.id,
+            kind="ExperimentTrendsQuery",
+            count_query=count_query,
+            exposure_query=exposure_query,
+        )
+
+        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
+        experiment.save()
+
+        query_runner = ExperimentTrendsQueryRunner(
+            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        )
+        with freeze_time("2023-01-07"):
+            with self.assertRaises(KeyError) as context:
+                query_runner.calculate()
+
+        self.assertEqual(str(context.exception), "'invalid_table_name'")
+
+    # Uses the same values as test_query_runner_with_data_warehouse_series_avg_amount for easy comparison
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_with_avg_math(self):
+        feature_flag = self.create_feature_flag()
+        experiment = self.create_experiment(feature_flag=feature_flag)
+
+        feature_flag_property = f"$feature/{feature_flag.key}"
+
+        count_query = TrendsQuery(
+            series=[
+                EventsNode(event="purchase", math="avg", math_property="amount", math_property_type="event_properties")
+            ]
+        )
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+
+        experiment_query = ExperimentTrendsQuery(
+            experiment_id=experiment.id,
+            kind="ExperimentTrendsQuery",
+            count_query=count_query,
+            exposure_query=exposure_query,
+        )
+
+        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
+        experiment.save()
+
+        query_runner = ExperimentTrendsQueryRunner(
+            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        )
+
+        # Populate exposure events - same as data warehouse test
+        for variant, count in [("control", 1), ("test", 3)]:
+            for i in range(count):
+                _create_event(
+                    team=self.team,
+                    event="$feature_flag_called",
+                    distinct_id=f"user_{variant}_{i}",
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                    },
+                    timestamp=datetime(2020, 1, i + 1),
+                )
+
+        # Create purchase events with same amounts as data warehouse test
+        # Control: 1 purchase of 100
+        # Test: 3 purchases of 50, 75, and 80
+        _create_event(
+            team=self.team,
+            event="purchase",
+            distinct_id="user_control_0",
+            properties={feature_flag_property: "control", "amount": 100},
+            timestamp=datetime(2020, 1, 2),
+        )
+
+        _create_event(
+            team=self.team,
+            event="purchase",
+            distinct_id="user_test_1",
+            properties={feature_flag_property: "test", "amount": 50},
+            timestamp=datetime(2020, 1, 2),
+        )
+        _create_event(
+            team=self.team,
+            event="purchase",
+            distinct_id="user_test_2",
+            properties={feature_flag_property: "test", "amount": 75},
+            timestamp=datetime(2020, 1, 3),
+        )
+        _create_event(
+            team=self.team,
+            event="purchase",
+            distinct_id="user_test_3",
+            properties={feature_flag_property: "test", "amount": 80},
+            timestamp=datetime(2020, 1, 6),
+        )
+
+        flush_persons_and_events()
+
+        prepared_count_query = query_runner.prepared_count_query
+        self.assertEqual(prepared_count_query.series[0].math, "sum")
+
+        result = query_runner.calculate()
+        trend_result = cast(ExperimentTrendsQueryResponse, result)
+
+        self.assertEqual(len(result.variants), 2)
+
+        control_result = next(variant for variant in trend_result.variants if variant.key == "control")
+        test_result = next(variant for variant in trend_result.variants if variant.key == "test")
+
+        control_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "control")
+        test_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "test")
+
+        self.assertEqual(control_result.count, 100)
+        self.assertAlmostEqual(test_result.count, 205)
+        self.assertEqual(control_result.absolute_exposure, 1)
+        self.assertEqual(test_result.absolute_exposure, 3)
+
+        self.assertEqual(
+            control_insight["data"],
+            [0.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0],
+        )
+        self.assertEqual(
+            test_insight["data"],
+            [0.0, 50.0, 125.0, 125.0, 125.0, 205.0, 205.0, 205.0, 205.0, 205.0, 205.0, 205.0, 205.0, 205.0, 205.0],
+        )
+
+    @flaky(max_runs=10, min_passes=1)
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_standard_flow(self):
+        feature_flag = self.create_feature_flag()
+        experiment = self.create_experiment(feature_flag=feature_flag)
+
+        ff_property = f"$feature/{feature_flag.key}"
+        count_query = TrendsQuery(series=[EventsNode(event="$pageview")])
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+
+        experiment_query = ExperimentTrendsQuery(
+            experiment_id=experiment.id,
+            kind="ExperimentTrendsQuery",
+            count_query=count_query,
+            exposure_query=exposure_query,
+        )
+
+        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
+        experiment.save()
+
+        journeys_for(
+            {
+                "user_control_1": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "control"}},
+                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "control"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "control",
+                            ff_property: "control",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+                "user_control_2": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "control"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "control",
+                            ff_property: "control",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+                "user_test_1": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
+                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "test"}},
+                    {"event": "$pageview", "timestamp": "2020-01-04", "properties": {ff_property: "test"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "test",
+                            ff_property: "test",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+                "user_test_2": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
+                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "test"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "test",
+                            ff_property: "test",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+            },
+            self.team,
+        )
+
+        flush_persons_and_events()
+
+        query_runner = ExperimentTrendsQueryRunner(
+            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        )
+        self.assertEqual(query_runner.stats_version, 1)
+        result = query_runner.calculate()
+
+        self.assertEqual(len(result.variants), 2)
+        for variant in result.variants:
+            self.assertIn(variant.key, ["control", "test"])
+
+        control_variant = next(v for v in result.variants if v.key == "control")
+        test_variant = next(v for v in result.variants if v.key == "test")
+
+        self.assertEqual(control_variant.count, 3)
+        self.assertEqual(test_variant.count, 5)
+        self.assertEqual(control_variant.absolute_exposure, 2)
+        self.assertEqual(test_variant.absolute_exposure, 2)
+
+        self.assertAlmostEqual(result.credible_intervals["control"][0], 0.5449, places=3)
+        self.assertAlmostEqual(result.credible_intervals["control"][1], 4.3836, places=3)
+        self.assertAlmostEqual(result.credible_intervals["test"][0], 1.1009, places=3)
+        self.assertAlmostEqual(result.credible_intervals["test"][1], 5.8342, places=3)
+
+        self.assertAlmostEqual(result.p_value, 1.0, places=3)
+
+        self.assertAlmostEqual(result.probability["control"], 0.2549, places=2)
+        self.assertAlmostEqual(result.probability["test"], 0.7453, places=2)
+
+        self.assertEqual(result.significance_code, ExperimentSignificanceCode.NOT_ENOUGH_EXPOSURE)
+
+        self.assertFalse(result.significant)
+
+        self.assertEqual(len(result.variants), 2)
 
         self.assertEqual(control_variant.absolute_exposure, 2.0)
         self.assertEqual(control_variant.count, 3.0)
@@ -746,6 +1399,344 @@ def test_query_runner_standard_flow(self):
         self.assertEqual(test_variant.count, 5.0)
         self.assertEqual(test_variant.exposure, 1.0)
 
+    @flaky(max_runs=10, min_passes=1)
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_standard_flow_v2_stats(self):
+        feature_flag = self.create_feature_flag()
+        experiment = self.create_experiment(feature_flag=feature_flag)
+
+        ff_property = f"$feature/{feature_flag.key}"
+        count_query = TrendsQuery(series=[EventsNode(event="$pageview")])
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+
+        experiment_query = ExperimentTrendsQuery(
+            experiment_id=experiment.id,
+            kind="ExperimentTrendsQuery",
+            count_query=count_query,
+            exposure_query=exposure_query,
+            stats_version=2,
+        )
+
+        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
+        experiment.save()
+
+        journeys_for(
+            {
+                "user_control_1": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "control"}},
+                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "control"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "control",
+                            ff_property: "control",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+                "user_control_2": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "control"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "control",
+                            ff_property: "control",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+                "user_test_1": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
+                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "test"}},
+                    {"event": "$pageview", "timestamp": "2020-01-04", "properties": {ff_property: "test"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "test",
+                            ff_property: "test",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+                "user_test_2": [
+                    {"event": "$pageview", "timestamp": "2020-01-02", "properties": {ff_property: "test"}},
+                    {"event": "$pageview", "timestamp": "2020-01-03", "properties": {ff_property: "test"}},
+                    {
+                        "event": "$feature_flag_called",
+                        "timestamp": "2020-01-02",
+                        "properties": {
+                            "$feature_flag_response": "test",
+                            ff_property: "test",
+                            "$feature_flag": feature_flag.key,
+                        },
+                    },
+                ],
+            },
+            self.team,
+        )
+
+        flush_persons_and_events()
+
+        query_runner = ExperimentTrendsQueryRunner(
+            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        )
+        self.assertEqual(query_runner.stats_version, 2)
+        result = query_runner.calculate()
+
+        self.assertEqual(len(result.variants), 2)
+        for variant in result.variants:
+            self.assertIn(variant.key, ["control", "test"])
+
+        control_variant = next(v for v in result.variants if v.key == "control")
+        test_variant = next(v for v in result.variants if v.key == "test")
+
+        self.assertEqual(control_variant.count, 3)
+        self.assertEqual(test_variant.count, 5)
+        self.assertEqual(control_variant.absolute_exposure, 2)
+        self.assertEqual(test_variant.absolute_exposure, 2)
+
+        self.assertAlmostEqual(result.credible_intervals["control"][0], 0.3633, places=3)
+        self.assertAlmostEqual(result.credible_intervals["control"][1], 2.9224, places=3)
+        self.assertAlmostEqual(result.credible_intervals["test"][0], 0.7339, places=3)
+        self.assertAlmostEqual(result.credible_intervals["test"][1], 3.8894, places=3)
+
+        self.assertAlmostEqual(result.p_value, 1.0, places=3)
+
+        self.assertAlmostEqual(result.probability["control"], 0.2549, places=2)
+        self.assertAlmostEqual(result.probability["test"], 0.7453, places=2)
+
+        self.assertEqual(result.significance_code, ExperimentSignificanceCode.NOT_ENOUGH_EXPOSURE)
+
+        self.assertFalse(result.significant)
+
+        self.assertEqual(len(result.variants), 2)
+
+        self.assertEqual(control_variant.absolute_exposure, 2.0)
+        self.assertEqual(control_variant.count, 3.0)
+        self.assertEqual(control_variant.exposure, 1.0)
+
+        self.assertEqual(test_variant.absolute_exposure, 2.0)
+        self.assertEqual(test_variant.count, 5.0)
+        self.assertEqual(test_variant.exposure, 1.0)
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_sum(self):
+        self._test_query_runner_property_math(
+            math="sum",
+            expected_control={
+                "count": 10,
+                "absolute_exposure": 5,
+                "data": [0.0, 0.0, 1.0, 3.0, 6.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+            expected_test={
+                "count": 90,
+                "absolute_exposure": 10,
+                "data": [0.0, 0.0, 2.0, 6.0, 12.0, 20.0, 30.0, 42.0, 56.0, 72.0, 90.0, 90.0, 90.0, 90.0, 90.0],
+            },
+        )
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_avg(self):
+        self._test_query_runner_property_math(
+            math="avg",
+            expected_control={
+                "count": 10,
+                "absolute_exposure": 5,
+                "data": [0.0, 0.0, 1.0, 3.0, 6.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+            expected_test={
+                "count": 90,
+                "absolute_exposure": 10,
+                "data": [0.0, 0.0, 2.0, 6.0, 12.0, 20.0, 30.0, 42.0, 56.0, 72.0, 90.0, 90.0, 90.0, 90.0, 90.0],
+            },
+        )
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_min(self):
+        self._test_query_runner_property_math(
+            math="min",
+            expected_control={
+                "count": 5,
+                "absolute_exposure": 5,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0],
+            },
+            expected_test={
+                "count": 10,
+                "absolute_exposure": 10,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+        )
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_max(self):
+        self._test_query_runner_property_math(
+            math="max",
+            expected_control={
+                "count": 5,
+                "absolute_exposure": 5,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0],
+            },
+            expected_test={
+                "count": 10,
+                "absolute_exposure": 10,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+        )
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_median(self):
+        self._test_query_runner_property_math(
+            math="median",
+            expected_control={
+                "count": 5,
+                "absolute_exposure": 5,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0],
+            },
+            expected_test={
+                "count": 10,
+                "absolute_exposure": 10,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+        )
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_p90(self):
+        self._test_query_runner_property_math(
+            math="p90",
+            expected_control={
+                "count": 5,
+                "absolute_exposure": 5,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0],
+            },
+            expected_test={
+                "count": 10,
+                "absolute_exposure": 10,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+        )
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_p95(self):
+        self._test_query_runner_property_math(
+            math="p95",
+            expected_control={
+                "count": 5,
+                "absolute_exposure": 5,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0],
+            },
+            expected_test={
+                "count": 10,
+                "absolute_exposure": 10,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+        )
+
+    @freeze_time("2020-01-01T12:00:00Z")
+    def test_query_runner_property_math_p99(self):
+        self._test_query_runner_property_math(
+            math="p99",
+            expected_control={
+                "count": 5,
+                "absolute_exposure": 5,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0],
+            },
+            expected_test={
+                "count": 10,
+                "absolute_exposure": 10,
+                "data": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+            },
+        )
+
+    def _test_query_runner_property_math(self, math, expected_control, expected_test):
+        feature_flag = self.create_feature_flag()
+        experiment = self.create_experiment(feature_flag=feature_flag, start_date=datetime(2020, 1, 1))
+
+        feature_flag_property = f"$feature/{feature_flag.key}"
+
+        # control values are 0, 1, 2, 3, 4
+        # test values are 0, 2, 4, 6, 8, 10, 12, 14, 16, 18
+
+        # Populate metric + exposure events
+        for variant, count in [("control", 5), ("test", 10)]:
+            for i in range(count):
+                _create_event(
+                    team=self.team,
+                    event="$feature_flag_called",
+                    distinct_id=f"user_{variant}_{i}",
+                    properties={
+                        "$feature_flag_response": variant,
+                        feature_flag_property: variant,
+                        "$feature_flag": feature_flag.key,
+                    },
+                    timestamp=datetime(2020, 1, i + 1),
+                )
+                _create_event(
+                    team=self.team,
+                    event="purchase",
+                    distinct_id=f"user_{variant}_{i}",
+                    properties={
+                        feature_flag_property: variant,
+                        "amount": i * (1 if variant == "control" else 2),
+                    },
+                    timestamp=datetime(2020, 1, i + 2),
+                )
+
+        count_query = TrendsQuery(
+            series=[
+                EventsNode(
+                    event="purchase",
+                    math=math,
+                    math_property="amount",
+                    math_property_type="event_properties",
+                )
+            ]
+        )
+        exposure_query = TrendsQuery(series=[EventsNode(event="$feature_flag_called")])
+        experiment_query = ExperimentTrendsQuery(
+            experiment_id=experiment.id,
+            kind="ExperimentTrendsQuery",
+            count_query=count_query,
+            exposure_query=exposure_query,
+        )
+
+        experiment.metrics = [{"type": "primary", "query": experiment_query.model_dump()}]
+        experiment.save()
+
+        query_runner = ExperimentTrendsQueryRunner(
+            query=ExperimentTrendsQuery(**experiment.metrics[0]["query"]), team=self.team
+        )
+
+        flush_persons_and_events()
+
+        result = query_runner.calculate()
+
+        trend_result = cast(ExperimentTrendsQueryResponse, result)
+
+        self.assertEqual(len(result.variants), 2)
+
+        control_result = next(variant for variant in trend_result.variants if variant.key == "control")
+        test_result = next(variant for variant in trend_result.variants if variant.key == "test")
+
+        control_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "control")
+        test_insight = next(variant for variant in trend_result.insight if variant["breakdown_value"] == "test")
+
+        self.assertEqual(control_result.count, expected_control["count"])
+        self.assertEqual(test_result.count, expected_test["count"])
+        self.assertEqual(control_result.absolute_exposure, expected_control["absolute_exposure"])
+        self.assertEqual(test_result.absolute_exposure, expected_test["absolute_exposure"])
+
+        self.assertEqual(
+            control_insight["data"],
+            expected_control["data"],
+        )
+        self.assertEqual(
+            test_insight["data"],
+            expected_test["data"],
+        )
+
     @freeze_time("2020-01-01T12:00:00Z")
     def test_validate_event_variants_no_events(self):
         feature_flag = self.create_feature_flag()
diff --git a/posthog/hogql_queries/experiments/test/test_trends_statistics.py b/posthog/hogql_queries/experiments/test/test_trends_statistics.py
new file mode 100644
index 0000000000000..b2bea591bc83b
--- /dev/null
+++ b/posthog/hogql_queries/experiments/test/test_trends_statistics.py
@@ -0,0 +1,295 @@
+from posthog.hogql_queries.experiments import MIN_PROBABILITY_FOR_SIGNIFICANCE
+from posthog.schema import ExperimentVariantTrendsBaseStats, ExperimentSignificanceCode
+from posthog.hogql_queries.experiments.trends_statistics_v2 import (
+    calculate_probabilities_v2,
+    are_results_significant_v2,
+    calculate_credible_intervals_v2,
+)
+from posthog.hogql_queries.experiments.trends_statistics import (
+    calculate_probabilities,
+    are_results_significant,
+    calculate_credible_intervals,
+)
+from posthog.test.base import APIBaseTest
+
+
+def create_variant(key: str, count: int, exposure: int) -> ExperimentVariantTrendsBaseStats:
+    return ExperimentVariantTrendsBaseStats(key=key, count=count, exposure=exposure, absolute_exposure=exposure)
+
+
+def create_variant_with_different_exposures(
+    key: str,
+    count: int,
+    exposure: float,  # relative exposure
+    absolute_exposure: int,  # absolute exposure
+) -> ExperimentVariantTrendsBaseStats:
+    return ExperimentVariantTrendsBaseStats(
+        key=key, count=count, exposure=exposure, absolute_exposure=absolute_exposure
+    )
+
+
+class TestExperimentTrendsStatistics(APIBaseTest):
+    def run_test_for_both_implementations(self, test_fn):
+        """Run the same test for both implementations"""
+        # Run for original implementation
+        test_fn(
+            stats_version=1,
+            calculate_probabilities=calculate_probabilities,
+            are_results_significant=are_results_significant,
+            calculate_credible_intervals=calculate_credible_intervals,
+        )
+        # Run for v2 implementation
+        test_fn(
+            stats_version=2,
+            calculate_probabilities=calculate_probabilities_v2,
+            are_results_significant=are_results_significant_v2,
+            calculate_credible_intervals=calculate_credible_intervals_v2,
+        )
+
+    def test_small_sample_two_variants_not_significant(self):
+        """Test with small sample size, two variants, no clear winner"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            control = create_variant("control", count=10, exposure=100)
+            test = create_variant("test", count=11, exposure=100)
+
+            probabilities = calculate_probabilities(control, [test])
+            significance, p_value = are_results_significant(control, [test], probabilities)
+            intervals = calculate_credible_intervals([control, test])
+
+            self.assertEqual(len(probabilities), 2)
+            self.assertTrue(0.4 < probabilities[0] < 0.6)  # Close to 50/50
+            self.assertTrue(0.4 < probabilities[1] < 0.6)  # Close to 50/50
+            self.assertEqual(significance, ExperimentSignificanceCode.LOW_WIN_PROBABILITY)
+            self.assertEqual(p_value, 1)
+
+            # Control: ~10% conversion rate with wide interval due to small sample
+            self.assertAlmostEqual(intervals["control"][0], 0.055, places=2)  # Lower bound ~5.5%
+            self.assertAlmostEqual(intervals["control"][1], 0.182, places=2)  # Upper bound ~18.2%
+
+            # Test: ~11% conversion rate with wide interval due to small sample
+            self.assertAlmostEqual(intervals["test"][0], 0.062, places=2)  # Lower bound ~6.2%
+            self.assertAlmostEqual(intervals["test"][1], 0.195, places=2)  # Upper bound ~19.5%
+
+        self.run_test_for_both_implementations(run_test)
+
+    def test_large_sample_two_variants_significant(self):
+        """Test with large sample size, two variants, clear winner"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            control = create_variant("control", count=1000, exposure=10000)
+            test = create_variant("test", count=1200, exposure=10000)
+
+            probabilities = calculate_probabilities(control, [test])
+            significance, p_value = are_results_significant(control, [test], probabilities)
+            intervals = calculate_credible_intervals([control, test])
+
+            self.assertEqual(len(probabilities), 2)
+            self.assertTrue(probabilities[1] > 0.95)  # Test variant strongly winning
+            self.assertTrue(probabilities[0] < 0.05)  # Control variant strongly losing
+            self.assertEqual(significance, ExperimentSignificanceCode.SIGNIFICANT)
+            if stats_version == 2:
+                self.assertEqual(p_value, 0)
+            else:
+                self.assertLess(p_value, 0.001)
+
+            # Control: 10% conversion rate with narrow interval due to large sample
+            self.assertAlmostEqual(intervals["control"][0], 0.094, places=2)  # Lower bound ~9.4%
+            self.assertAlmostEqual(intervals["control"][1], 0.106, places=2)  # Upper bound ~10.6%
+
+            # Test: 12% conversion rate with narrow interval due to large sample
+            self.assertAlmostEqual(intervals["test"][0], 0.114, places=2)  # Lower bound ~11.4%
+            self.assertAlmostEqual(intervals["test"][1], 0.126, places=2)  # Upper bound ~12.6%
+
+        self.run_test_for_both_implementations(run_test)
+
+    def test_large_sample_two_variants_strongly_significant(self):
+        """Test with large sample size, two variants, very clear winner"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            control = create_variant("control", count=1000, exposure=10000)
+            test = create_variant("test", count=1500, exposure=10000)
+
+            probabilities = calculate_probabilities(control, [test])
+            significance, p_value = are_results_significant(control, [test], probabilities)
+            intervals = calculate_credible_intervals([control, test])
+
+            self.assertEqual(len(probabilities), 2)
+            self.assertTrue(probabilities[1] > 0.99)  # Test variant very strongly winning
+            self.assertTrue(probabilities[0] < 0.01)  # Control variant very strongly losing
+            self.assertEqual(significance, ExperimentSignificanceCode.SIGNIFICANT)
+            if stats_version == 2:
+                self.assertEqual(p_value, 0)
+            else:
+                self.assertLess(p_value, 0.001)
+
+            # Control: 10% conversion rate
+            self.assertAlmostEqual(intervals["control"][0], 0.094, places=2)  # Lower bound ~9.4%
+            self.assertAlmostEqual(intervals["control"][1], 0.106, places=2)  # Upper bound ~10.6%
+
+            # Test: 15% conversion rate, clearly higher than control
+            self.assertAlmostEqual(intervals["test"][0], 0.143, places=2)  # Lower bound ~14.3%
+            self.assertAlmostEqual(intervals["test"][1], 0.157, places=2)  # Upper bound ~15.7%
+
+        self.run_test_for_both_implementations(run_test)
+
+    def test_many_variants_not_significant(self):
+        """Test with multiple variants, no clear winner"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            control = create_variant("control", count=100, exposure=1000)
+            test_a = create_variant("test_a", count=98, exposure=1000)
+            test_b = create_variant("test_b", count=102, exposure=1000)
+            test_c = create_variant("test_c", count=101, exposure=1000)
+
+            probabilities = calculate_probabilities(control, [test_a, test_b, test_c])
+            significance, p_value = are_results_significant(control, [test_a, test_b, test_c], probabilities)
+            intervals = calculate_credible_intervals([control, test_a, test_b, test_c])
+
+            self.assertEqual(len(probabilities), 4)
+            self.assertTrue(all(p < MIN_PROBABILITY_FOR_SIGNIFICANCE for p in probabilities))
+            self.assertEqual(significance, ExperimentSignificanceCode.LOW_WIN_PROBABILITY)
+            self.assertEqual(p_value, 1)
+
+            # All variants around 10% with overlapping intervals
+            self.assertAlmostEqual(intervals["control"][0], 0.083, places=2)  # ~8.3%
+            self.assertAlmostEqual(intervals["control"][1], 0.119, places=2)  # ~11.9%
+
+            self.assertAlmostEqual(intervals["test_a"][0], 0.081, places=2)  # ~8.1%
+            self.assertAlmostEqual(intervals["test_a"][1], 0.117, places=2)  # ~11.7%
+
+            self.assertAlmostEqual(intervals["test_b"][0], 0.085, places=2)  # ~8.5%
+            self.assertAlmostEqual(intervals["test_b"][1], 0.121, places=2)  # ~12.1%
+
+            self.assertAlmostEqual(intervals["test_c"][0], 0.084, places=2)  # ~8.4%
+            self.assertAlmostEqual(intervals["test_c"][1], 0.120, places=2)  # ~12.0%
+
+        self.run_test_for_both_implementations(run_test)
+
+    def test_many_variants_significant(self):
+        """Test with multiple variants, one clear winner"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            control = create_variant("control", count=1000, exposure=10000)
+            test_a = create_variant("test_a", count=1050, exposure=10000)
+            test_b = create_variant("test_b", count=1500, exposure=10000)
+            test_c = create_variant("test_c", count=1100, exposure=10000)
+
+            probabilities = calculate_probabilities(control, [test_a, test_b, test_c])
+            significance, p_value = are_results_significant(control, [test_a, test_b, test_c], probabilities)
+            intervals = calculate_credible_intervals([control, test_a, test_b, test_c])
+
+            self.assertEqual(len(probabilities), 4)
+            self.assertTrue(probabilities[2] > 0.9)  # test_b should be winning
+            self.assertTrue(probabilities[1] < 0.1)  # test_a should be losing
+            self.assertTrue(probabilities[0] < 0.1)  # control should be losing
+            self.assertEqual(significance, ExperimentSignificanceCode.SIGNIFICANT)
+            if stats_version == 2:
+                self.assertEqual(p_value, 0)
+            else:
+                self.assertLess(p_value, 0.001)
+
+            # Control at 10%
+            self.assertAlmostEqual(intervals["control"][0], 0.094, places=2)
+            self.assertAlmostEqual(intervals["control"][1], 0.106, places=2)
+
+            # Test A slightly higher at 10.5%
+            self.assertAlmostEqual(intervals["test_a"][0], 0.099, places=2)
+            self.assertAlmostEqual(intervals["test_a"][1], 0.111, places=2)
+
+            # Test B clearly winning at 15%
+            self.assertAlmostEqual(intervals["test_b"][0], 0.143, places=2)
+            self.assertAlmostEqual(intervals["test_b"][1], 0.157, places=2)
+
+            # Test C slightly higher at 11%
+            self.assertAlmostEqual(intervals["test_c"][0], 0.104, places=2)
+            self.assertAlmostEqual(intervals["test_c"][1], 0.116, places=2)
+
+        self.run_test_for_both_implementations(run_test)
+
+    def test_insufficient_sample_size(self):
+        """Test with sample size below threshold"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            control = create_variant("control", count=5, exposure=50)
+            test = create_variant("test", count=8, exposure=50)
+
+            probabilities = calculate_probabilities(control, [test])
+            significance, p_value = are_results_significant(control, [test], probabilities)
+            intervals = calculate_credible_intervals([control, test])
+
+            self.assertEqual(len(probabilities), 2)
+            # Assert individual probabilities
+            self.assertTrue(probabilities[0] < 0.5)  # Control has lower probability
+            self.assertTrue(probabilities[1] > 0.5)  # Test has higher probability
+            self.assertEqual(significance, ExperimentSignificanceCode.NOT_ENOUGH_EXPOSURE)
+            self.assertEqual(p_value, 1.0)
+
+            # Both variants should have wide intervals due to small sample size
+            self.assertAlmostEqual(intervals["control"][0], 0.044, places=2)  # 4.4%
+            self.assertAlmostEqual(intervals["control"][1], 0.229, places=2)  # 22.9%
+
+            self.assertAlmostEqual(intervals["test"][0], 0.083, places=2)  # 8.3%
+            if stats_version == 2:
+                self.assertAlmostEqual(intervals["test"][1], 0.309, places=2)  # 30.9%
+            else:
+                self.assertAlmostEqual(intervals["test"][1], 0.315, places=2)  # 31.5%
+
+        self.run_test_for_both_implementations(run_test)
+
+    def test_edge_cases(self):
+        """Test edge cases like zero counts"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            control = create_variant("control", count=0, exposure=1000)
+            test = create_variant("test", count=0, exposure=1000)
+
+            probabilities = calculate_probabilities(control, [test])
+            significance, p_value = are_results_significant(control, [test], probabilities)
+            intervals = calculate_credible_intervals([control, test])
+
+            self.assertEqual(len(probabilities), 2)
+            self.assertTrue(abs(probabilities[0] - 0.5) < 0.1)  # Should be close to 50/50
+            self.assertTrue(abs(probabilities[1] - 0.5) < 0.1)  # Should be close to 50/50
+            self.assertEqual(significance, ExperimentSignificanceCode.LOW_WIN_PROBABILITY)
+            self.assertEqual(p_value, 1)
+
+            # Both variants should have very small intervals near zero
+            self.assertAlmostEqual(intervals["control"][0], 0.0, places=3)
+            self.assertAlmostEqual(intervals["control"][1], 0.004, places=3)
+
+            self.assertAlmostEqual(intervals["test"][0], 0.0, places=3)
+            self.assertAlmostEqual(intervals["test"][1], 0.004, places=3)
+
+        self.run_test_for_both_implementations(run_test)
+
+    def test_different_relative_and_absolute_exposure(self):
+        """Test that credible intervals are calculated using absolute_exposure rather than relative exposure"""
+
+        def run_test(stats_version, calculate_probabilities, are_results_significant, calculate_credible_intervals):
+            # Control has exposure=1 (relative) but absolute_exposure=10000
+            control = create_variant_with_different_exposures(
+                "control", count=1000, exposure=1, absolute_exposure=10000
+            )
+            # Test has exposure=1.2 (relative) but absolute_exposure=12000
+            test = create_variant_with_different_exposures("test", count=1200, exposure=1.2, absolute_exposure=12000)
+
+            probabilities = calculate_probabilities(control, [test])
+            significance, p_value = are_results_significant(control, [test], probabilities)
+            intervals = calculate_credible_intervals([control, test])
+
+            self.assertEqual(len(probabilities), 2)
+            self.assertTrue(0.4 < probabilities[0] < 0.6)  # Close to 50/50
+            self.assertTrue(0.4 < probabilities[1] < 0.6)  # Close to 50/50
+            self.assertEqual(significance, ExperimentSignificanceCode.LOW_WIN_PROBABILITY)
+            self.assertEqual(p_value, 1)
+
+            # Control at ~10% conversion rate
+            self.assertAlmostEqual(intervals["control"][0], 0.094, places=2)
+            self.assertAlmostEqual(intervals["control"][1], 0.106, places=2)
+
+            # Test at ~10% conversion rate
+            self.assertAlmostEqual(intervals["test"][0], 0.094, places=2)
+            self.assertAlmostEqual(intervals["test"][1], 0.106, places=2)
+
+        self.run_test_for_both_implementations(run_test)
diff --git a/posthog/hogql_queries/experiments/trends_statistics_v2.py b/posthog/hogql_queries/experiments/trends_statistics_v2.py
new file mode 100644
index 0000000000000..fa4bf4be31210
--- /dev/null
+++ b/posthog/hogql_queries/experiments/trends_statistics_v2.py
@@ -0,0 +1,204 @@
+from rest_framework.exceptions import ValidationError
+from sentry_sdk import capture_exception
+from posthog.hogql_queries.experiments import FF_DISTRIBUTION_THRESHOLD, MIN_PROBABILITY_FOR_SIGNIFICANCE
+from posthog.hogql_queries.experiments.funnels_statistics import Probability
+from posthog.schema import ExperimentSignificanceCode, ExperimentVariantTrendsBaseStats
+from scipy.stats import gamma
+import numpy as np
+
+# Prior parameters (minimal prior knowledge)
+PRIOR_ALPHA = 1
+PRIOR_BETA = 1
+
+SAMPLE_SIZE = 10000
+
+
+def calculate_probabilities_v2(
+    control_variant: ExperimentVariantTrendsBaseStats, test_variants: list[ExperimentVariantTrendsBaseStats]
+) -> list[float]:
+    """
+    Calculate the win probabilities for each variant in an experiment using Bayesian analysis.
+
+    This function computes the probability that each variant is the best (i.e., has the highest
+    conversion rate) compared to all other variants, including the control. It uses samples
+    drawn from the posterior distributions of each variant's conversion rate.
+
+    Parameters:
+    -----------
+    control_variant : ExperimentVariantTrendsBaseStats
+        Statistics for the control group, including count (successes) and exposure (total trials)
+    test_variants : list[ExperimentVariantTrendsBaseStats]
+        List of statistics for test variants to compare against the control
+
+    Returns:
+    --------
+    list[float]
+        A list of probabilities where:
+        - The first element is the probability that the control variant is the best
+        - Subsequent elements are the probabilities that each test variant is the best
+
+    Notes:
+    ------
+    - Uses a Bayesian approach with a Beta distribution as the posterior
+    - Assumes a minimally informative prior (alpha=1, beta=1)
+    - Draws samples from the posterior to estimate win probabilities
+
+    Example:
+    --------
+    >>> control = ExperimentVariantTrendsBaseStats(key="control", count=100, exposure=1000, absolute_exposure=1000)
+    >>> test = ExperimentVariantTrendsBaseStats(key="test", count=120, exposure=1000, absolute_exposure=1000)
+    >>> probabilities = calculate_probabilities_v2(control, [test])
+    >>> # Returns: [0.085, 0.915] indicating the test variant is more likely to be the best
+    """
+    if len(test_variants) >= 10:
+        raise ValidationError("Can't calculate experiment results for more than 10 variants", code="too_much_data")
+    if len(test_variants) < 1:
+        raise ValidationError("Can't calculate experiment results for less than 2 variants", code="no_data")
+
+    # Calculate posterior parameters for control
+    alpha_control = PRIOR_ALPHA + control_variant.count
+    beta_control = PRIOR_BETA + control_variant.absolute_exposure
+
+    # Draw samples from control posterior
+    samples_control = gamma.rvs(alpha_control, scale=1 / beta_control, size=SAMPLE_SIZE)
+
+    # Draw samples for each test variant
+    test_samples = []
+    for test in test_variants:
+        alpha_test = PRIOR_ALPHA + test.count
+        beta_test = PRIOR_BETA + test.absolute_exposure
+        test_samples.append(gamma.rvs(alpha_test, scale=1 / beta_test, size=SAMPLE_SIZE))
+
+    # Calculate probabilities
+    probabilities = []
+
+    # Probability control wins (beats all test variants)
+    control_wins = np.all([samples_control > test_sample for test_sample in test_samples], axis=0)
+    probabilities.append(float(np.mean(control_wins)))
+
+    # Probability each test variant wins (beats control and all other test variants)
+    for i, test_sample in enumerate(test_samples):
+        other_test_samples = test_samples[:i] + test_samples[i + 1 :]
+        variant_wins = np.all(
+            [test_sample > samples_control] + [test_sample > other for other in other_test_samples], axis=0
+        )
+        probabilities.append(float(np.mean(variant_wins)))
+
+    return probabilities
+
+
+def are_results_significant_v2(
+    control_variant: ExperimentVariantTrendsBaseStats,
+    test_variants: list[ExperimentVariantTrendsBaseStats],
+    probabilities: list[Probability],
+) -> tuple[ExperimentSignificanceCode, Probability]:
+    """
+    Determines if experiment results are statistically significant using Bayesian analysis.
+
+    This function evaluates the win probabilities of each variant to determine if any variant
+    is significantly better than the others. The method:
+    1. Checks if sample sizes meet minimum threshold requirements
+    2. Evaluates win probabilities from the posterior distributions
+
+    Parameters:
+    -----------
+    control_variant : ExperimentVariantTrendsBaseStats
+        Statistics for the control group, including count and exposure data
+    test_variants : list[ExperimentVariantTrendsBaseStats]
+        List of statistics for test variants to compare against control
+    probabilities : list[Probability]
+        List of win probabilities for each variant, as calculated by calculate_probabilities
+
+    Returns:
+    --------
+    tuple[ExperimentSignificanceCode, Probability]
+        - ExperimentSignificanceCode indicating the significance status:
+            NOT_ENOUGH_EXPOSURE: Insufficient sample size
+            LOW_WIN_PROBABILITY: No variant has a high enough probability of being best
+            SIGNIFICANT: Clear winner with high probability of being best
+        - Probability value (1.0 for NOT_ENOUGH_EXPOSURE and LOW_WIN_PROBABILITY, 0.0 for SIGNIFICANT)
+
+    Notes:
+    ------
+    - Uses a Bayesian approach to determine significance
+    - Does not use credible interval comparisons
+    - p_value is a placeholder (1.0 or 0.0) to indicate significance status
+    """
+    # Check exposure thresholds
+    for variant in test_variants:
+        if variant.absolute_exposure < FF_DISTRIBUTION_THRESHOLD:
+            return ExperimentSignificanceCode.NOT_ENOUGH_EXPOSURE, 1.0
+
+    if control_variant.absolute_exposure < FF_DISTRIBUTION_THRESHOLD:
+        return ExperimentSignificanceCode.NOT_ENOUGH_EXPOSURE, 1.0
+
+    # Find highest probability among all variants
+    max_probability = max(probabilities)
+
+    # Check if any variant has a high enough probability of being best
+    if max_probability < MIN_PROBABILITY_FOR_SIGNIFICANCE:
+        return ExperimentSignificanceCode.LOW_WIN_PROBABILITY, 1.0
+
+    return ExperimentSignificanceCode.SIGNIFICANT, 0.0
+
+
+def calculate_credible_intervals_v2(variants, lower_bound=0.025, upper_bound=0.975):
+    """
+    Calculate Bayesian credible intervals for each variant's conversion rate.
+
+    Credible intervals represent the range where we believe the true conversion rate lies
+    with a specified probability (default 95%). Unlike frequentist confidence intervals,
+    these have a direct probabilistic interpretation: "There is a 95% probability that
+    the true conversion rate lies within this interval."
+
+    Parameters:
+    -----------
+    variants : list[ExperimentVariantTrendsBaseStats]
+        List of variants containing count (successes) and exposure (total trials) data
+    lower_bound : float, optional (default=0.025)
+        Lower percentile for the credible interval (2.5% for 95% CI)
+    upper_bound : float, optional (default=0.975)
+        Upper percentile for the credible interval (97.5% for 95% CI)
+
+    Returns:
+    --------
+    dict[str, tuple[float, float]]
+        Dictionary mapping variant keys to their credible intervals
+        Each interval is a tuple of (lower_bound, upper_bound)
+
+    Notes:
+    ------
+    - Uses a Gamma distribution as the posterior distribution
+    - Assumes a minimally informative prior (alpha=1, beta=1)
+    - Intervals are calculated for visualization purposes, not for significance testing
+    - Returns empty dict if any calculations fail
+
+    Example:
+    --------
+    >>> variants = [
+    ...     ExperimentVariantTrendsBaseStats(key="control", count=100, exposure=1000, absolute_exposure=1000),
+    ...     ExperimentVariantTrendsBaseStats(key="test", count=150, exposure=1000, absolute_exposure=1000)
+    ... ]
+    >>> intervals = calculate_credible_intervals_v2(variants)
+    >>> # Returns: {"control": (0.082, 0.122), "test": (0.128, 0.176)}
+    """
+    intervals = {}
+
+    for variant in variants:
+        try:
+            # Calculate posterior parameters using absolute_exposure
+            alpha_posterior = PRIOR_ALPHA + variant.count
+            beta_posterior = PRIOR_BETA + variant.absolute_exposure
+
+            # Calculate credible intervals using the posterior distribution
+            credible_interval = gamma.ppf([lower_bound, upper_bound], alpha_posterior, scale=1 / beta_posterior)
+
+            intervals[variant.key] = (float(credible_interval[0]), float(credible_interval[1]))
+        except Exception as e:
+            capture_exception(
+                Exception(f"Error calculating credible interval for variant {variant.key}"),
+                {"error": str(e)},
+            )
+            return {}
+
+    return intervals
diff --git a/posthog/hogql_queries/insights/funnels/base.py b/posthog/hogql_queries/insights/funnels/base.py
index 1c7fb05d13f69..8d11a84473f48 100644
--- a/posthog/hogql_queries/insights/funnels/base.py
+++ b/posthog/hogql_queries/insights/funnels/base.py
@@ -37,7 +37,7 @@
 )
 from posthog.types import EntityNode, ExclusionEntityNode
 
-JOIN_ALGOS = "direct,parallel_hash,hash,full_sorting_merge"
+JOIN_ALGOS = "auto"
 
 
 class FunnelBase(ABC):
@@ -115,9 +115,11 @@ def breakdown_cohorts(self) -> list[Cohort]:
         team, breakdown = self.context.team, self.context.breakdown
 
         if isinstance(breakdown, list):
-            cohorts = Cohort.objects.filter(team_id=team.pk, pk__in=[b for b in breakdown if b != "all"])
+            cohorts = Cohort.objects.filter(
+                team__project_id=team.project_id, pk__in=[b for b in breakdown if b != "all"]
+            )
         else:
-            cohorts = Cohort.objects.filter(team_id=team.pk, pk=breakdown)
+            cohorts = Cohort.objects.filter(team__project_id=team.project_id, pk=breakdown)
 
         return list(cohorts)
 
@@ -724,7 +726,9 @@ def _build_step_query(
             first_time_filter = parse_expr("e.uuid IN {subquery}", placeholders={"subquery": subquery})
             return ast.And(exprs=[*filters, first_time_filter])
         elif entity.math == FunnelMathType.FIRST_TIME_FOR_USER_WITH_FILTERS:
-            subquery = FirstTimeForUserAggregationQuery(self.context, ast.Constant(value=1), filter_expr).to_query()
+            subquery = FirstTimeForUserAggregationQuery(
+                self.context, ast.Constant(value=1), ast.And(exprs=filters)
+            ).to_query()
             first_time_filter = parse_expr("e.uuid IN {subquery}", placeholders={"subquery": subquery})
             return ast.And(exprs=[*filters, first_time_filter])
         elif len(filters) > 1:
diff --git a/posthog/hogql_queries/insights/funnels/funnel_trends_udf.py b/posthog/hogql_queries/insights/funnels/funnel_trends_udf.py
index 40d15aae68a69..cc7b5a7928d13 100644
--- a/posthog/hogql_queries/insights/funnels/funnel_trends_udf.py
+++ b/posthog/hogql_queries/insights/funnels/funnel_trends_udf.py
@@ -7,6 +7,7 @@
 from posthog.hogql.parser import parse_select, parse_expr
 from posthog.hogql_queries.insights.funnels import FunnelTrends
 from posthog.hogql_queries.insights.funnels.base import JOIN_ALGOS
+from posthog.hogql_queries.insights.funnels.funnel_udf import FunnelUDFMixin
 from posthog.hogql_queries.insights.utils.utils import get_start_of_interval_hogql_str
 from posthog.schema import BreakdownType, BreakdownAttributionType
 from posthog.utils import DATERANGE_MAP, relative_date_parse
@@ -15,7 +16,7 @@
 HUMAN_READABLE_TIMESTAMP_FORMAT = "%-d-%b-%Y"
 
 
-class FunnelTrendsUDF(FunnelTrends):
+class FunnelTrendsUDF(FunnelUDFMixin, FunnelTrends):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # In base, these fields only get added if you're running an actors query
@@ -65,8 +66,6 @@ def _inner_aggregation_query(self):
         else:
             inner_event_query = self._get_inner_event_query_for_udf(entity_name="events")
 
-        default_breakdown_selector = "[]" if self._query_has_array_breakdown() else "''"
-
         # stores the steps as an array of integers from 1 to max_steps
         # so if the event could be step_0, step_1 or step_4, it looks like [1,2,0,0,5]
 
@@ -89,8 +88,7 @@ def _inner_aggregation_query(self):
             fn = "aggregate_funnel_trends"
             breakdown_prop = ""
 
-        prop_selector = "prop" if self.context.breakdown else default_breakdown_selector
-        prop_vals = "groupUniqArray(prop)" if self.context.breakdown else f"[{default_breakdown_selector}]"
+        prop_selector = "prop" if self.context.breakdown else self._default_breakdown_selector()
 
         breakdown_attribution_string = f"{self.context.breakdownAttributionType}{f'_{self.context.funnelsFilter.breakdownAttributionValue}' if self.context.breakdownAttributionType == BreakdownAttributionType.STEP else ''}"
 
@@ -114,7 +112,7 @@ def _inner_aggregation_query(self):
                     {self.conversion_window_limit()},
                     '{breakdown_attribution_string}',
                     '{self.context.funnelsFilter.funnelOrderType}',
-                    {prop_vals},
+                    {self._prop_vals()},
                     {self.udf_event_array_filter()}
                 )) as af_tuple,
                 toTimeZone(toDateTime(_toUInt64(af_tuple.1)), '{self.context.team.timezone}') as entrance_period_start,
diff --git a/posthog/hogql_queries/insights/funnels/funnel_udf.py b/posthog/hogql_queries/insights/funnels/funnel_udf.py
index 1bc07d685da02..94bfcffb9ad42 100644
--- a/posthog/hogql_queries/insights/funnels/funnel_udf.py
+++ b/posthog/hogql_queries/insights/funnels/funnel_udf.py
@@ -1,17 +1,78 @@
-from typing import cast, Optional
+from typing import cast, Optional, runtime_checkable
 
 from posthog.hogql import ast
 from posthog.hogql.constants import DEFAULT_RETURNED_ROWS, HogQLQuerySettings
 from posthog.hogql.parser import parse_select, parse_expr
 from posthog.hogql_queries.insights.funnels.base import FunnelBase, JOIN_ALGOS
+from posthog.hogql_queries.insights.funnels.funnel_query_context import FunnelQueryContext
 from posthog.schema import BreakdownType, BreakdownAttributionType
 from posthog.utils import DATERANGE_MAP
 
+from typing import Protocol
+
+
+@runtime_checkable
+class FunnelProtocol(Protocol):
+    context: FunnelQueryContext
+
+    def _query_has_array_breakdown(self) -> bool: ...
+
+    def _default_breakdown_selector(self) -> str: ...
+
+
 TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S"
 HUMAN_READABLE_TIMESTAMP_FORMAT = "%-d-%b-%Y"
 
 
-class FunnelUDF(FunnelBase):
+class FunnelUDFMixin:
+    def _add_breakdown_attribution_subquery(self: FunnelProtocol, inner_query: ast.SelectQuery) -> ast.SelectQuery:
+        breakdown, breakdownAttributionType = (
+            self.context.breakdown,
+            self.context.breakdownAttributionType,
+        )
+
+        if breakdownAttributionType in [
+            BreakdownAttributionType.FIRST_TOUCH,
+            BreakdownAttributionType.LAST_TOUCH,
+        ]:
+            # When breaking down by first/last touch, each person can only have one prop value
+            # so just select that. Except for the empty case, where we select the default.
+
+            if self._query_has_array_breakdown():
+                assert isinstance(breakdown, list)
+                default_breakdown_value = f"""[{','.join(["''" for _ in range(len(breakdown or []))])}]"""
+                # default is [''] when dealing with a single breakdown array, otherwise ['', '', ...., '']
+                breakdown_selector = parse_expr(
+                    f"if(notEmpty(arrayFilter(x -> notEmpty(x), prop_vals)), prop_vals, {default_breakdown_value})"
+                )
+            else:
+                breakdown_selector = ast.Field(chain=["prop_vals"])
+
+            return ast.SelectQuery(
+                select=[ast.Field(chain=["*"]), ast.Alias(alias="prop", expr=breakdown_selector)],
+                select_from=ast.JoinExpr(table=inner_query),
+            )
+
+        return inner_query
+
+    def _prop_vals(self: FunnelProtocol):
+        prop_vals = f"[{self._default_breakdown_selector()}]"
+        if self.context.breakdown:
+            if self.context.breakdownAttributionType == BreakdownAttributionType.STEP:
+                prop = f"prop_{self.context.funnelsFilter.breakdownAttributionValue}"
+            else:
+                prop = "prop"
+            if self._query_has_array_breakdown():
+                prop_vals = f"groupUniqArrayIf({prop}, {prop} != [])"
+            else:
+                prop_vals = f"groupUniqArray({prop})"
+        return prop_vals
+
+    def _default_breakdown_selector(self: FunnelProtocol) -> str:
+        return "[]" if self._query_has_array_breakdown() else "''"
+
+
+class FunnelUDF(FunnelUDFMixin, FunnelBase):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # In base, these fields only get added if you're running an actors query
@@ -50,8 +111,6 @@ def _inner_aggregation_query(self):
         else:
             inner_event_query = self._get_inner_event_query_for_udf(entity_name="events")
 
-        default_breakdown_selector = "[]" if self._query_has_array_breakdown() else "''"
-
         # stores the steps as an array of integers from 1 to max_steps
         # so if the event could be step_0, step_1 or step_4, it looks like [1,2,0,0,5]
 
@@ -73,8 +132,9 @@ def _inner_aggregation_query(self):
             fn = "aggregate_funnel"
             breakdown_prop = ""
 
-        prop_selector = "prop" if self.context.breakdown else default_breakdown_selector
-        prop_vals = "groupUniqArray(prop)" if self.context.breakdown else f"[{default_breakdown_selector}]"
+        prop_selector = "prop" if self.context.breakdown else self._default_breakdown_selector()
+
+        prop_vals = self._prop_vals()
 
         breakdown_attribution_string = f"{self.context.breakdownAttributionType}{f'_{self.context.funnelsFilter.breakdownAttributionValue}' if self.context.breakdownAttributionType == BreakdownAttributionType.STEP else ''}"
 
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel.ambr
index 2315f2b51ebf6..f4f8c1a300c85 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel.ambr
@@ -98,12 +98,12 @@
 # ---
 # name: TestFOSSFunnel.test_funnel_conversion_window_seconds.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -184,16 +184,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -506,12 +501,12 @@
 # ---
 # name: TestFOSSFunnel.test_funnel_with_property_groups.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -603,16 +598,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [1, 2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -624,12 +614,12 @@
 # ---
 # name: TestFOSSFunnel.test_funnel_with_property_groups.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -721,16 +711,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -742,12 +727,12 @@
 # ---
 # name: TestFOSSFunnel.test_funnel_with_property_groups.3
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -839,16 +824,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1719,10 +1699,11 @@
 # ---
 # name: TestFunnelGroupBreakdown.test_funnel_breakdown_group.1
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -1840,15 +1821,11 @@
      WHERE and(ifNull(in(steps, [1, 2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(prop)))
                                                        and isNull(arrayFlatten(array('finance')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1860,10 +1837,11 @@
 # ---
 # name: TestFunnelGroupBreakdown.test_funnel_breakdown_group.2
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -1981,15 +1959,11 @@
      WHERE and(ifNull(in(steps, [2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(prop)))
                                                     and isNull(arrayFlatten(array('finance')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2001,10 +1975,11 @@
 # ---
 # name: TestFunnelGroupBreakdown.test_funnel_breakdown_group.3
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -2122,15 +2097,11 @@
      WHERE and(ifNull(in(steps, [1, 2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(prop)))
                                                        and isNull(arrayFlatten(array('technology')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2142,10 +2113,11 @@
 # ---
 # name: TestFunnelGroupBreakdown.test_funnel_breakdown_group.4
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -2263,15 +2235,11 @@
      WHERE and(ifNull(in(steps, [2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(prop)))
                                                     and isNull(arrayFlatten(array('technology')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation.ambr
index f95e83e21b1d9..a7e5388a8e251 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation.ambr
@@ -316,12 +316,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -429,60 +430,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -507,12 +459,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties.3
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -620,60 +573,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -698,12 +602,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties.5
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -811,60 +716,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -889,12 +745,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties.7
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -1002,60 +859,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1242,12 +1050,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties_materialized.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -1355,60 +1164,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1433,12 +1193,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties_materialized.3
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -1546,60 +1307,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1624,12 +1336,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties_materialized.5
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -1737,60 +1450,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1815,12 +1479,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelation.test_basic_funnel_correlation_with_properties_materialized.7
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -1928,60 +1593,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'paid'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2419,7 +2035,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2511,16 +2128,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2534,7 +2146,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2626,16 +2239,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2649,7 +2257,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2741,16 +2350,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2764,7 +2368,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2856,16 +2461,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3027,7 +2627,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -3119,16 +2720,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3142,7 +2738,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -3234,16 +2831,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3389,7 +2981,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -3481,16 +3074,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3504,7 +3092,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -3596,16 +3185,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3619,7 +3203,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -3711,16 +3296,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3734,7 +3314,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -3826,16 +3407,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3997,7 +3573,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -4089,16 +3666,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4112,7 +3684,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -4204,16 +3777,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4374,7 +3942,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -4473,16 +4042,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4496,7 +4060,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -4595,16 +4160,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4618,7 +4178,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -4717,16 +4278,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4740,7 +4296,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -4839,16 +4396,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5156,7 +4708,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -5255,16 +4808,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5278,7 +4826,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -5377,16 +4926,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5400,7 +4944,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -5499,16 +5044,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5522,7 +5062,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -5621,16 +5162,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5938,7 +5474,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -6037,16 +5574,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -6060,7 +5592,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -6159,16 +5692,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -6182,7 +5710,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -6281,16 +5810,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -6304,7 +5828,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -6403,16 +5928,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -6720,7 +6240,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -6819,16 +6340,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -6842,7 +6358,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -6941,16 +6458,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -6964,7 +6476,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -7063,16 +6576,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -7086,7 +6594,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -7185,16 +6694,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -7502,7 +7006,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -7601,16 +7106,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -7624,7 +7124,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -7723,16 +7224,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -7746,7 +7242,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -7845,16 +7342,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -7868,7 +7360,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -7967,16 +7460,11 @@
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors.ambr
index ca6d26d135828..cebec4f9efd4b 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors.ambr
@@ -1,12 +1,13 @@
 # serializer version: 1
 # name: TestFunnelCorrelationActors.test_funnel_correlation_on_event_with_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM events AS event
      LEFT OUTER JOIN
        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -112,58 +113,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed']), equals(event.event, 'insight loaded'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM events AS event
-                                                       LEFT OUTER JOIN
-                                                         (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                          FROM person_distinct_id_overrides
-                                                          WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                          GROUP BY person_distinct_id_overrides.distinct_id
-                                                          HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS event__override ON equals(event.distinct_id, event__override.distinct_id)
-                                                       JOIN
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, '$pageview'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'insight analyzed'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('$pageview', 'insight analyzed'))), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
-                                                       WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed']), equals(event.event, 'insight loaded'), ifNull(equals(funnel_actors.steps, 2), 0))
-                                                       GROUP BY actor_id
-                                                       ORDER BY actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -188,12 +142,13 @@
 # ---
 # name: TestFunnelCorrelationActors.test_funnel_correlation_on_event_with_recordings.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM events AS event
      LEFT OUTER JOIN
        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -365,70 +320,11 @@
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed', 'insight updated']), equals(event.event, 'insight loaded'), ifNull(notEquals(funnel_actors.steps, 3), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM events AS event
-                                                       LEFT OUTER JOIN
-                                                         (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                          FROM person_distinct_id_overrides
-                                                          WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                          GROUP BY person_distinct_id_overrides.distinct_id
-                                                          HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS event__override ON equals(event.distinct_id, event__override.distinct_id)
-                                                       JOIN
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(step_2_matching_event) AS step_2_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_2, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, avg(step_2_conversion_time) AS step_2_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner, median(step_2_conversion_time) AS step_2_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, tuple(latest_2, uuid_2, `$session_id_2`, `$window_id_2`) AS step_2_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, if(isNull(latest_2), step_1_matching_event, step_2_matching_event))) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, step_2_conversion_time AS step_2_conversion_time, latest_0 AS latest_0, latest_2 AS latest_2, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, step_2 AS step_2, latest_2 AS latest_2, uuid_2 AS uuid_2, `$session_id_2` AS `$session_id_2`, `$window_id_2` AS `$window_id_2`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0), ifNull(lessOrEquals(latest_1, latest_2), 0), ifNull(lessOrEquals(latest_2, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 3, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1)) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, if(and(isNotNull(latest_2), ifNull(lessOrEquals(latest_2, plus(toTimeZone(latest_1, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_1, latest_2), NULL) AS step_2_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, tuple(latest_2, uuid_2, `$session_id_2`, `$window_id_2`) AS step_2_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, if(isNull(latest_2), step_1_matching_event, step_2_matching_event))) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, step_2 AS step_2, min(latest_2) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_2, last_value(uuid_2) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_2, last_value(`$session_id_2`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_2`, last_value(`$window_id_2`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_2`
-                                                                      FROM
-                                                                        (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, step_2 AS step_2, if(ifNull(less(latest_2, latest_1), 0), NULL, latest_2) AS latest_2, if(ifNull(less(latest_2, latest_1), 0), NULL, uuid_2) AS uuid_2, if(ifNull(less(latest_2, latest_1), 0), NULL, `$session_id_2`) AS `$session_id_2`, if(ifNull(less(latest_2, latest_1), 0), NULL, `$window_id_2`) AS `$window_id_2`
-                                                                         FROM
-                                                                           (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`, step_2 AS step_2, min(latest_2) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_2, last_value(uuid_2) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_2, last_value(`$session_id_2`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_2`, last_value(`$window_id_2`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_2`
-                                                                            FROM
-                                                                              (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, '$pageview'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'insight analyzed'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`, if(equals(e.event, 'insight updated'), 1, 0) AS step_2, if(ifNull(equals(step_2, 1), 0), timestamp, NULL) AS latest_2, if(ifNull(equals(step_2, 1), 0), uuid, NULL) AS uuid_2, if(ifNull(equals(step_2, 1), 0), e.`$session_id`, NULL) AS `$session_id_2`, if(ifNull(equals(step_2, 1), 0), e.`$window_id`, NULL) AS `$window_id_2`
-                                                                               FROM events AS e
-                                                                               LEFT OUTER JOIN
-                                                                                 (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                  FROM person_distinct_id_overrides
-                                                                                  WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                  GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                  HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                               WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('$pageview', 'insight analyzed', 'insight updated'))), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0), ifNull(equals(step_2, 1), 0)))))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2, 3]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
-                                                       WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed', 'insight updated']), equals(event.event, 'insight loaded'), ifNull(notEquals(funnel_actors.steps, 3), 1))
-                                                       GROUP BY actor_id
-                                                       ORDER BY actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -453,12 +349,13 @@
 # ---
 # name: TestFunnelCorrelationActors.test_funnel_correlation_on_properties_with_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                final_matching_events AS matching_events,
@@ -566,60 +463,11 @@
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, final_matching_events AS matching_events, timestamp AS timestamp, steps AS steps, final_timestamp AS final_timestamp, first_timestamp AS first_timestamp
-                                                          FROM
-                                                            (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events, groupArray(10)(step_1_matching_event) AS step_1_matching_events, groupArray(10)(final_matching_event) AS final_matching_events, aggregation_target AS aggregation_target, steps AS steps, argMax(latest_0, steps) AS timestamp, argMax(latest_1, steps) AS final_timestamp, argMax(latest_0, steps) AS first_timestamp, avg(step_1_conversion_time) AS step_1_average_conversion_time_inner, median(step_1_conversion_time) AS step_1_median_conversion_time_inner
-                                                             FROM
-                                                               (SELECT tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event, aggregation_target AS aggregation_target, steps AS steps, max(steps) OVER (PARTITION BY aggregation_target) AS max_steps, step_1_conversion_time AS step_1_conversion_time, latest_0 AS latest_0, latest_1 AS latest_1, latest_0 AS latest_0
-                                                                FROM
-                                                                  (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, latest_1 AS latest_1, uuid_1 AS uuid_1, `$session_id_1` AS `$session_id_1`, `$window_id_1` AS `$window_id_1`, if(and(ifNull(lessOrEquals(latest_0, latest_1), 0), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), 2, 1) AS steps, if(and(isNotNull(latest_1), ifNull(lessOrEquals(latest_1, plus(toTimeZone(latest_0, 'UTC'), toIntervalDay(14))), 0)), dateDiff('second', latest_0, latest_1), NULL) AS step_1_conversion_time, tuple(latest_0, uuid_0, `$session_id_0`, `$window_id_0`) AS step_0_matching_event, tuple(latest_1, uuid_1, `$session_id_1`, `$window_id_1`) AS step_1_matching_event, if(isNull(latest_0), tuple(NULL, NULL, NULL, NULL), if(isNull(latest_1), step_0_matching_event, step_1_matching_event)) AS final_matching_event
-                                                                   FROM
-                                                                     (SELECT aggregation_target AS aggregation_target, timestamp AS timestamp, step_0 AS step_0, latest_0 AS latest_0, uuid_0 AS uuid_0, `$session_id_0` AS `$session_id_0`, `$window_id_0` AS `$window_id_0`, step_1 AS step_1, min(latest_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS latest_1, last_value(uuid_1) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                     ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS uuid_1, last_value(`$session_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$session_id_1`, last_value(`$window_id_1`) OVER (PARTITION BY aggregation_target
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) AS `$window_id_1`
-                                                                      FROM
-                                                                        (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, if(equals(e.event, '$pageview'), 1, 0) AS step_0, if(ifNull(equals(step_0, 1), 0), timestamp, NULL) AS latest_0, if(ifNull(equals(step_0, 1), 0), uuid, NULL) AS uuid_0, if(ifNull(equals(step_0, 1), 0), e.`$session_id`, NULL) AS `$session_id_0`, if(ifNull(equals(step_0, 1), 0), e.`$window_id`, NULL) AS `$window_id_0`, if(equals(e.event, 'insight analyzed'), 1, 0) AS step_1, if(ifNull(equals(step_1, 1), 0), timestamp, NULL) AS latest_1, if(ifNull(equals(step_1, 1), 0), uuid, NULL) AS uuid_1, if(ifNull(equals(step_1, 1), 0), e.`$session_id`, NULL) AS `$session_id_1`, if(ifNull(equals(step_1, 1), 0), e.`$window_id`, NULL) AS `$window_id_1`
-                                                                         FROM events AS e
-                                                                         LEFT OUTER JOIN
-                                                                           (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                            FROM person_distinct_id_overrides
-                                                                            WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                            GROUP BY person_distinct_id_overrides.distinct_id
-                                                                            HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                         LEFT JOIN
-                                                                           (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'foo'), ''), 'null'), '^"|"$', '') AS properties___foo
-                                                                            FROM person
-                                                                            WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                 (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                  FROM person
-                                                                                                                                  WHERE equals(person.team_id, 99999)
-                                                                                                                                  GROUP BY person.id
-                                                                                                                                  HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                         WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('$pageview', 'insight analyzed')), ifNull(equals(e__person.properties___foo, 'bar'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))))
-                                                                   WHERE ifNull(equals(step_0, 1), 0)))
-                                                             GROUP BY aggregation_target, steps
-                                                             HAVING ifNull(equals(steps, max(max_steps)), isNull(steps)
-                                                                           and isNull(max(max_steps))))
-                                                          WHERE ifNull(in(steps, [1, 2]), 0)
-                                                          ORDER BY aggregation_target ASC) AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors_udf.ambr
index bc580c8b79bd9..62ae8ccd05b01 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_actors_udf.ambr
@@ -1,12 +1,13 @@
 # serializer version: 1
 # name: TestFunnelCorrelationsActorsUDF.test_funnel_correlation_on_event_with_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM events AS event
      LEFT OUTER JOIN
        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -26,7 +27,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -60,54 +61,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed']), equals(event.event, 'insight loaded'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM events AS event
-                                                       LEFT OUTER JOIN
-                                                         (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                          FROM person_distinct_id_overrides
-                                                          WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                          GROUP BY person_distinct_id_overrides.distinct_id
-                                                          HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS event__override ON equals(event.distinct_id, event__override.distinct_id)
-                                                       JOIN
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, '$pageview'), 1, 0) AS step_0, if(equals(e.event, 'insight analyzed'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('$pageview', 'insight analyzed'))), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
-                                                       WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed']), equals(event.event, 'insight loaded'), ifNull(equals(funnel_actors.steps, 2), 0))
-                                                       GROUP BY actor_id
-                                                       ORDER BY actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -132,12 +94,13 @@
 # ---
 # name: TestFunnelCorrelationsActorsUDF.test_funnel_correlation_on_event_with_recordings.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM events AS event
      LEFT OUTER JOIN
        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -157,7 +120,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -192,54 +155,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed', 'insight updated']), equals(event.event, 'insight loaded'), ifNull(notEquals(funnel_actors.steps, 3), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM events AS event
-                                                       LEFT OUTER JOIN
-                                                         (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                          FROM person_distinct_id_overrides
-                                                          WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                          GROUP BY person_distinct_id_overrides.distinct_id
-                                                          HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS event__override ON equals(event.distinct_id, event__override.distinct_id)
-                                                       JOIN
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[3][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                             and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, '$pageview'), 1, 0) AS step_0, if(equals(e.event, 'insight analyzed'), 1, 0) AS step_1, if(equals(e.event, 'insight updated'), 1, 0) AS step_2
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('$pageview', 'insight analyzed', 'insight updated'))), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0), ifNull(equals(step_2, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
-                                                       WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2021-01-08 23:59:59', 6, 'UTC')))), notIn(event.event, ['$pageview', 'insight analyzed', 'insight updated']), equals(event.event, 'insight loaded'), ifNull(notEquals(funnel_actors.steps, 3), 1))
-                                                       GROUP BY actor_id
-                                                       ORDER BY actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -264,12 +188,13 @@
 # ---
 # name: TestFunnelCorrelationsActorsUDF.test_funnel_correlation_on_properties_with_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -281,7 +206,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -325,56 +250,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, '$pageview'), 1, 0) AS step_0, if(equals(e.event, 'insight analyzed'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'foo'), ''), 'null'), '^"|"$', '') AS properties___foo
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2021-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('$pageview', 'insight analyzed')), ifNull(equals(e__person.properties___foo, 'bar'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_udf.ambr
index 1ef2e20dafbba..d1b1edaa350d1 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_correlation_udf.ambr
@@ -22,7 +22,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -56,7 +56,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(if(not(empty(event__override.distinct_id)), event__override.person_id, event.person_id), funnel_actors.actor_id)
   WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), notIn(event.event, []))
   GROUP BY name
   LIMIT 100
@@ -74,7 +74,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -108,7 +108,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -137,7 +137,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -171,7 +171,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      JOIN
        (SELECT persons.id AS id,
                persons.properties AS person_props
@@ -202,7 +202,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -236,7 +236,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -248,12 +248,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -265,7 +266,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -309,56 +310,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -383,12 +343,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties.3
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -400,7 +361,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -444,56 +405,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -518,12 +438,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties.5
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -535,7 +456,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -579,56 +500,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -653,12 +533,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties.7
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -670,7 +551,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -714,56 +595,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, '$browser'), ''), 'null'), '^"|"$', '') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -805,7 +645,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -839,7 +679,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      JOIN
        (SELECT persons.id AS id,
                persons.properties AS person_props
@@ -870,7 +710,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -904,7 +744,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -916,12 +756,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties_materialized.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -933,7 +774,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -977,56 +818,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1051,12 +851,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties_materialized.3
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -1068,7 +869,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1112,56 +913,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Positive'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1186,12 +946,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties_materialized.5
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -1203,7 +964,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1247,56 +1008,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(equals(funnel_actors.steps, 2), 0)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1321,12 +1041,13 @@
 # ---
 # name: TestClickhouseFunnelCorrelationUDF.test_basic_funnel_correlation_with_properties_materialized.7
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -1338,7 +1059,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1382,56 +1103,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT funnel_actors.actor_id AS actor_id, any(funnel_actors.matching_events) AS matching_events
-                                                       FROM
-                                                         (SELECT aggregation_target AS actor_id, matched_events_array[plus(step_reached, 1)] AS matching_events, (matched_events_array[1][1]).1 AS timestamp, nullIf((matched_events_array[2][1]).1, 0) AS final_timestamp, (matched_events_array[1][1]).1 AS first_timestamp, steps AS steps, final_timestamp, first_timestamp
-                                                          FROM
-                                                            (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array, arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple, af_tuple.1 AS step_reached, plus(af_tuple.1, 1) AS steps, af_tuple.2 AS breakdown, af_tuple.3 AS timings, af_tuple.4 AS matched_event_uuids_array_array, groupArray(tuple(timestamp, uuid, `$session_id`, `$window_id`)) AS user_events, mapFromArrays(arrayMap(x -> x.2, user_events), user_events) AS user_events_map, arrayMap(matched_event_uuids_array -> arrayMap(event_uuid -> user_events_map[event_uuid], arrayDistinct(matched_event_uuids_array)), matched_event_uuids_array_array) AS matched_events_array, aggregation_target AS aggregation_target
-                                                             FROM
-                                                               (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp, if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target, e.uuid AS uuid, e.`$session_id` AS `$session_id`, e.`$window_id` AS `$window_id`, if(equals(e.event, 'user signed up'), 1, 0) AS step_0, if(equals(e.event, 'paid'), 1, 0) AS step_1
-                                                                FROM events AS e
-                                                                LEFT OUTER JOIN
-                                                                  (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                   FROM person_distinct_id_overrides
-                                                                   WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                   GROUP BY person_distinct_id_overrides.distinct_id
-                                                                   HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-                                                                LEFT JOIN
-                                                                  (SELECT person.id AS id, nullIf(nullIf(person.`pmat_$browser`, ''), 'null') AS `properties___$browser`
-                                                                   FROM person
-                                                                   WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                        (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                         FROM person
-                                                                                                                         WHERE equals(person.team_id, 99999)
-                                                                                                                         GROUP BY person.id
-                                                                                                                         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS e__person ON equals(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id), e__person.id)
-                                                                WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-14 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('paid', 'user signed up')), ifNull(equals(e__person.`properties___$browser`, 'Negative'), 0)), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
-                                                             GROUP BY aggregation_target
-                                                             HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
-                                                          WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-                                                          ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
-                                                       WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
-                                                       GROUP BY funnel_actors.actor_id
-                                                       ORDER BY funnel_actors.actor_id ASC) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1475,7 +1155,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1502,7 +1182,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_1`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_1`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), in(event.event, ['positively_related', 'negatively_related'])))
   GROUP BY name,
            prop
@@ -1522,7 +1202,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1549,7 +1229,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -1580,7 +1260,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1607,7 +1287,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_1`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_1`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), in(event.event, ['positively_related', 'negatively_related'])))
   GROUP BY name,
            prop
@@ -1627,7 +1307,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1654,7 +1334,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -1680,7 +1360,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1707,7 +1387,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
   WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), notIn(event.event, []))
   GROUP BY name
   LIMIT 100
@@ -1725,7 +1405,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1752,7 +1432,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -1767,7 +1447,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -1780,7 +1461,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1807,20 +1488,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1834,7 +1510,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -1847,7 +1524,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1874,20 +1551,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1901,7 +1573,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -1914,7 +1587,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1941,20 +1614,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1968,7 +1636,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -1981,7 +1650,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2008,20 +1677,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2046,7 +1710,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2081,7 +1745,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
   WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), notIn(event.event, []))
   GROUP BY name
   LIMIT 100
@@ -2099,7 +1763,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2134,7 +1798,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -2149,7 +1813,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2162,7 +1827,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2189,20 +1854,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2216,7 +1876,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2229,7 +1890,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2256,20 +1917,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2294,7 +1950,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2321,7 +1977,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
   WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), notIn(event.event, []))
   GROUP BY name
   LIMIT 100
@@ -2339,7 +1995,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2366,7 +2022,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -2381,7 +2037,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2394,7 +2051,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2421,20 +2078,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2448,7 +2100,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2461,7 +2114,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2488,20 +2141,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'positively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2515,7 +2163,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2528,7 +2177,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2555,20 +2204,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2582,7 +2226,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2595,7 +2240,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2622,20 +2267,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2660,7 +2300,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2695,7 +2335,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
   WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), notIn(event.event, []))
   GROUP BY name
   LIMIT 100
@@ -2713,7 +2353,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2748,7 +2388,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -2763,7 +2403,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2776,7 +2417,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2803,20 +2444,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(equals(funnel_actors.steps, 2), 0))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2830,7 +2466,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM events AS event
      JOIN
        (SELECT aggregation_target AS actor_id,
@@ -2843,7 +2480,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2870,20 +2507,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors ON equals(funnel_actors.actor_id, event.`$group_0`)
      WHERE and(equals(event.team_id, 99999), greaterOrEquals(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-01 00:00:00', 6, 'UTC'))), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC'))), equals(event.team_id, 99999), greater(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), funnel_actors.first_timestamp), less(toTimeZone(toDateTime(toTimeZone(event.timestamp, 'UTC'), 'UTC'), 'UTC'), coalesce(funnel_actors.final_timestamp, plus(toTimeZone(funnel_actors.first_timestamp, 'UTC'), toIntervalDay(14)), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-14 23:59:59', 6, 'UTC')))), notIn(event.event, ['paid', 'user signed up']), equals(event.event, 'negatively_related'), ifNull(notEquals(funnel_actors.steps, 2), 1))
      GROUP BY actor_id
      ORDER BY actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2911,7 +2543,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2938,7 +2570,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -2968,7 +2600,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -2995,7 +2627,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -3010,7 +2642,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3022,7 +2655,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3057,20 +2690,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3084,7 +2712,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3096,7 +2725,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3131,20 +2760,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3158,7 +2782,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3170,7 +2795,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3205,20 +2830,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3232,7 +2852,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3244,7 +2865,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3279,20 +2900,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3320,7 +2936,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3347,7 +2963,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -3377,7 +2993,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3404,7 +3020,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -3433,7 +3049,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3460,7 +3076,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -3490,7 +3106,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3517,7 +3133,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -3532,7 +3148,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3544,7 +3161,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3579,20 +3196,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3606,7 +3218,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3618,7 +3231,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3653,20 +3266,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3680,7 +3288,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3692,7 +3301,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3727,20 +3336,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3754,7 +3358,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -3766,7 +3371,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3801,20 +3406,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3842,7 +3442,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3869,7 +3469,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -3899,7 +3499,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3926,7 +3526,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -3955,7 +3555,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -3982,7 +3582,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -4012,7 +3612,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4039,7 +3639,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -4054,7 +3654,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4066,7 +3667,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4101,20 +3702,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4128,7 +3724,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4140,7 +3737,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4175,20 +3772,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4202,7 +3794,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4214,7 +3807,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4249,20 +3842,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4276,7 +3864,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4288,7 +3877,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4323,20 +3912,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4364,7 +3948,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4391,7 +3975,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -4421,7 +4005,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4448,7 +4032,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -4477,7 +4061,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4504,7 +4088,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -4534,7 +4118,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4561,7 +4145,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -4576,7 +4160,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4588,7 +4173,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4623,20 +4208,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4650,7 +4230,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4662,7 +4243,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4697,20 +4278,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4724,7 +4300,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4736,7 +4313,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4771,20 +4348,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4798,7 +4370,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -4810,7 +4383,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4845,20 +4418,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4886,7 +4454,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4913,7 +4481,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -4943,7 +4511,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -4970,7 +4538,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -4999,7 +4567,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5026,7 +4594,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -5056,7 +4624,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5083,7 +4651,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -5098,7 +4666,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -5110,7 +4679,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5145,20 +4714,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5172,7 +4736,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -5184,7 +4749,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5219,20 +4784,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5246,7 +4806,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -5258,7 +4819,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5293,20 +4854,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(equals(funnel_actors.steps, 2), 0)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5320,7 +4876,8 @@
   SELECT source.actor_id AS actor_id
   FROM
     (SELECT funnel_actors.actor_id AS actor_id,
-            any(funnel_actors.matching_events) AS matching_events
+            any(funnel_actors.matching_events) AS matching_events,
+            actor_id AS key
      FROM
        (SELECT aggregation_target AS actor_id,
                matched_events_array[plus(step_reached, 1)] AS matching_events,
@@ -5332,7 +4889,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5367,20 +4924,15 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      WHERE ifNull(notEquals(funnel_actors.steps, 2), 1)
      GROUP BY funnel_actors.actor_id
      ORDER BY funnel_actors.actor_id ASC) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5408,7 +4960,7 @@
                first_timestamp
         FROM
           (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-                  arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                  arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                 and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                 and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5435,7 +4987,7 @@
            GROUP BY aggregation_target
            HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
         WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-        ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+        ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
      LEFT JOIN
        (SELECT groups.key AS key,
                groups.properties AS properties
@@ -5465,7 +5017,7 @@
             first_timestamp
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -5492,7 +5044,7 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS funnel_actors
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS funnel_actors
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons.ambr
index f623ea36204cd..4c634d67842fc 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons.ambr
@@ -1,12 +1,13 @@
 # serializer version: 1
 # name: TestFunnelPersons.test_funnel_person_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            step_0_matching_events AS matching_events
+            step_0_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events,
                groupArray(10)(step_1_matching_event) AS step_1_matching_events,
@@ -154,15 +155,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [1, 2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -188,12 +185,13 @@
 # ---
 # name: TestFunnelPersons.test_funnel_person_recordings.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            step_1_matching_events AS matching_events
+            step_1_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events,
                groupArray(10)(step_1_matching_event) AS step_1_matching_events,
@@ -341,15 +339,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -375,12 +369,13 @@
 # ---
 # name: TestFunnelPersons.test_funnel_person_recordings.4
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            step_1_matching_events AS matching_events
+            step_1_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events,
                groupArray(10)(step_1_matching_event) AS step_1_matching_events,
@@ -528,15 +523,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(equals(steps, 2), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons_udf.ambr
index 370ed267d8b65..742e6b15740d6 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_persons_udf.ambr
@@ -1,15 +1,16 @@
 # serializer version: 1
 # name: TestFunnelPersonsUDF.test_funnel_person_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matched_events_array[1] AS matching_events
+            matched_events_array[1] AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -44,16 +45,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -79,15 +76,16 @@
 # ---
 # name: TestFunnelPersonsUDF.test_funnel_person_recordings.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matched_events_array[2] AS matching_events
+            matched_events_array[2] AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -122,16 +120,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 1), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -157,15 +151,16 @@
 # ---
 # name: TestFunnelPersonsUDF.test_funnel_person_recordings.4
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matched_events_array[2] AS matching_events
+            matched_events_array[2] AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -200,16 +195,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(equals(step_reached, 1), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict.ambr
index 163abb23ac305..dd6ed08f95fcc 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict.ambr
@@ -648,10 +648,11 @@
 # ---
 # name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.1
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -746,15 +747,11 @@
      WHERE and(ifNull(in(steps, [1, 2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(prop)))
                                                        and isNull(arrayFlatten(array('finance')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -766,10 +763,11 @@
 # ---
 # name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.2
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -864,15 +862,11 @@
      WHERE and(ifNull(in(steps, [2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(prop)))
                                                     and isNull(arrayFlatten(array('finance')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -884,10 +878,11 @@
 # ---
 # name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.3
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -982,15 +977,11 @@
      WHERE and(ifNull(in(steps, [1, 2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(prop)))
                                                        and isNull(arrayFlatten(array('technology')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1002,10 +993,11 @@
 # ---
 # name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.4
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -1100,15 +1092,11 @@
      WHERE and(ifNull(in(steps, [2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(prop)))
                                                     and isNull(arrayFlatten(array('technology')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1118,243 +1106,3 @@
                     allow_experimental_analyzer=1
   '''
 # ---
-# name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.5
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.6
-  '''
-  
-  SELECT aggregation_target AS actor_id
-  FROM
-    (SELECT aggregation_target,
-            steps,
-            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
-            avg(step_2_conversion_time) step_2_average_conversion_time_inner,
-            median(step_1_conversion_time) step_1_median_conversion_time_inner,
-            median(step_2_conversion_time) step_2_median_conversion_time_inner,
-            prop
-     FROM
-       (SELECT aggregation_target,
-               steps,
-               max(steps) over (PARTITION BY aggregation_target,
-                                             prop) as max_steps,
-                               step_1_conversion_time,
-                               step_2_conversion_time,
-                               prop
-        FROM
-          (SELECT *,
-                  if(latest_0 <= latest_1
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY
-                     AND latest_1 <= latest_2
-                     AND latest_2 <= latest_0 + INTERVAL 7 DAY, 3, if(latest_0 <= latest_1
-                                                                      AND latest_1 <= latest_0 + INTERVAL 7 DAY, 2, 1)) AS steps,
-                  if(isNotNull(latest_1)
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
-                  if(isNotNull(latest_2)
-                     AND latest_2 <= latest_1 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_1), toDateTime(latest_2)), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN 2 PRECEDING AND 2 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'sign up', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'play movie', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'buy', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (1=1) )))
-           WHERE step_0 = 1 ))
-     GROUP BY aggregation_target,
-              steps,
-              prop
-     HAVING steps = max(max_steps))
-  WHERE steps IN [1, 2, 3]
-    AND arrayFlatten(array(prop)) = arrayFlatten(array('technology'))
-  ORDER BY aggregation_target
-  LIMIT 100
-  OFFSET 0 SETTINGS max_ast_elements=1000000,
-                    max_expanded_ast_elements=1000000
-  '''
-# ---
-# name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.7
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestStrictFunnelGroupBreakdown.test_funnel_breakdown_group.8
-  '''
-  
-  SELECT aggregation_target AS actor_id
-  FROM
-    (SELECT aggregation_target,
-            steps,
-            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
-            avg(step_2_conversion_time) step_2_average_conversion_time_inner,
-            median(step_1_conversion_time) step_1_median_conversion_time_inner,
-            median(step_2_conversion_time) step_2_median_conversion_time_inner,
-            prop
-     FROM
-       (SELECT aggregation_target,
-               steps,
-               max(steps) over (PARTITION BY aggregation_target,
-                                             prop) as max_steps,
-                               step_1_conversion_time,
-                               step_2_conversion_time,
-                               prop
-        FROM
-          (SELECT *,
-                  if(latest_0 <= latest_1
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY
-                     AND latest_1 <= latest_2
-                     AND latest_2 <= latest_0 + INTERVAL 7 DAY, 3, if(latest_0 <= latest_1
-                                                                      AND latest_1 <= latest_0 + INTERVAL 7 DAY, 2, 1)) AS steps,
-                  if(isNotNull(latest_1)
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
-                  if(isNotNull(latest_2)
-                     AND latest_2 <= latest_1 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_1), toDateTime(latest_2)), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN 2 PRECEDING AND 2 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'sign up', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'play movie', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'buy', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (1=1) )))
-           WHERE step_0 = 1 ))
-     GROUP BY aggregation_target,
-              steps,
-              prop
-     HAVING steps = max(max_steps))
-  WHERE steps IN [2, 3]
-    AND arrayFlatten(array(prop)) = arrayFlatten(array('technology'))
-  ORDER BY aggregation_target
-  LIMIT 100
-  OFFSET 0 SETTINGS max_ast_elements=1000000,
-                    max_expanded_ast_elements=1000000
-  '''
-# ---
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons.ambr
index f2e6752d368d0..c3e986c70b196 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons.ambr
@@ -1,12 +1,13 @@
 # serializer version: 1
 # name: TestFunnelStrictStepsPersons.test_strict_funnel_person_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            step_0_matching_events AS matching_events
+            step_0_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events,
                groupArray(10)(step_1_matching_event) AS step_1_matching_events,
@@ -114,15 +115,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [1, 2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -148,12 +145,13 @@
 # ---
 # name: TestFunnelStrictStepsPersons.test_strict_funnel_person_recordings.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            step_1_matching_events AS matching_events
+            step_1_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events,
                groupArray(10)(step_1_matching_event) AS step_1_matching_events,
@@ -261,15 +259,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -295,12 +289,13 @@
 # ---
 # name: TestFunnelStrictStepsPersons.test_strict_funnel_person_recordings.4
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            step_1_matching_events AS matching_events
+            step_1_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT groupArray(10)(step_0_matching_event) AS step_0_matching_events,
                groupArray(10)(step_1_matching_event) AS step_1_matching_events,
@@ -408,15 +403,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(equals(steps, 2), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons_udf.ambr
index 328abd6df2e65..2c3b80f8467e3 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_persons_udf.ambr
@@ -1,15 +1,16 @@
 # serializer version: 1
 # name: TestFunnelStrictStepsPersons.test_strict_funnel_person_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matched_events_array[1] AS matching_events
+            matched_events_array[1] AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'strict', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'strict', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                             and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                             and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                            and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -44,16 +45,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -79,15 +76,16 @@
 # ---
 # name: TestFunnelStrictStepsPersons.test_strict_funnel_person_recordings.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matched_events_array[2] AS matching_events
+            matched_events_array[2] AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'strict', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'strict', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                             and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                             and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                            and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -122,16 +120,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 1), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -157,15 +151,16 @@
 # ---
 # name: TestFunnelStrictStepsPersons.test_strict_funnel_person_recordings.4
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matched_events_array[2] AS matching_events
+            matched_events_array[2] AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'strict', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'strict', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                             and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                             and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                            and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -200,16 +195,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(equals(step_reached, 1), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_udf.ambr
index d869459cb3485..9b7fba2117929 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_strict_udf.ambr
@@ -15,11 +15,12 @@
             if(ifNull(less(row_number, 25), 0), breakdown, ['Other']) AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                            and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                            and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                           and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                           and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'strict', groupUniqArrayIf(prop, ifNull(notEquals(prop, []), isNotNull(prop)
+                                                                                                                      or isNotNull([]))), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
+                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
                af_tuple.1 AS step_reached,
                plus(af_tuple.1, 1) AS steps,
                af_tuple.2 AS breakdown,
@@ -62,7 +63,7 @@
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -89,61 +90,45 @@
             if(ifNull(less(row_number, 25), 0), breakdown, ['Other']) AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'step_1', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                      and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'step_1', 'strict', groupUniqArrayIf(prop_1, ifNull(notEquals(prop_1, []), isNotNull(prop_1)
+                                                                                                                   or isNotNull([]))), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                                                                                                                                                                                                                                     and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
+                                                                                                                                                                                                                                                                     and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                    and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                                                    and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
                af_tuple.1 AS step_reached,
                plus(af_tuple.1, 1) AS steps,
                af_tuple.2 AS breakdown,
                af_tuple.3 AS timings,
                aggregation_target AS aggregation_target
         FROM
-          (SELECT timestamp AS timestamp,
-                  aggregation_target AS aggregation_target,
-                  uuid AS uuid,
-                          `$session_id` AS `$session_id`,
-                          `$window_id` AS `$window_id`,
-                          step_0 AS step_0,
-                          step_1 AS step_1,
-                          prop_basic AS prop_basic,
-                          prop_0 AS prop_0,
-                          prop_1 AS prop_1,
-                          prop,
-                          prop_vals AS prop_vals,
-                          prop
-           FROM
-             (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp,
-                     if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target,
-                     e.uuid AS uuid,
-                     e.`$session_id` AS `$session_id`,
-                     e.`$window_id` AS `$window_id`,
-                     if(equals(e.event, 'sign up'), 1, 0) AS step_0,
-                     if(and(equals(e.event, 'buy'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$version'), ''), 'null'), '^"|"$', ''), 'xyz'), 0)), 1, 0) AS step_1,
-                     [ifNull(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$browser'), ''), 'null'), '^"|"$', '')), '')] AS prop_basic,
-                     if(ifNull(equals(step_0, 1), 0), prop_basic, []) AS prop_0,
-                     if(ifNull(equals(step_1, 1), 0), prop_basic, []) AS prop_1,
-                     prop_1 AS prop,
-                     groupUniqArray(prop) OVER (PARTITION BY aggregation_target) AS prop_vals
-              FROM events AS e
-              LEFT OUTER JOIN
-                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
-                        person_distinct_id_overrides.distinct_id AS distinct_id
-                 FROM person_distinct_id_overrides
-                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                 GROUP BY person_distinct_id_overrides.distinct_id
-                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-              WHERE and(equals(e.team_id, 99999), and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-08 23:59:59.999999', 6, 'UTC'))))) ARRAY
-           JOIN prop_vals AS prop
-           WHERE ifNull(notEquals(prop, []), isNotNull(prop)
-                        or isNotNull([])))
+          (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp,
+                  if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target,
+                  e.uuid AS uuid,
+                  e.`$session_id` AS `$session_id`,
+                  e.`$window_id` AS `$window_id`,
+                  if(equals(e.event, 'sign up'), 1, 0) AS step_0,
+                  if(and(equals(e.event, 'buy'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$version'), ''), 'null'), '^"|"$', ''), 'xyz'), 0)), 1, 0) AS step_1,
+                  [ifNull(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$browser'), ''), 'null'), '^"|"$', '')), '')] AS prop_basic,
+                  if(ifNull(equals(step_0, 1), 0), prop_basic, []) AS prop_0,
+                  if(ifNull(equals(step_1, 1), 0), prop_basic, []) AS prop_1,
+                  prop_1 AS prop,
+                  groupUniqArray(prop) OVER (PARTITION BY aggregation_target) AS prop_vals
+           FROM events AS e
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-08 23:59:59.999999', 6, 'UTC')))))
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -170,11 +155,12 @@
             if(ifNull(less(row_number, 25), 0), breakdown, ['Other']) AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                            and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                            and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                           and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                           and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'strict', groupUniqArrayIf(prop, ifNull(notEquals(prop, []), isNotNull(prop)
+                                                                                                                      or isNotNull([]))), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                                                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
+                                                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
                af_tuple.1 AS step_reached,
                plus(af_tuple.1, 1) AS steps,
                af_tuple.2 AS breakdown,
@@ -217,7 +203,7 @@
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -249,7 +235,7 @@
             if(ifNull(less(row_number, 25), 0), breakdown, 'Other') AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -299,7 +285,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -331,7 +317,7 @@
             if(ifNull(less(row_number, 25), 0), breakdown, 'Other') AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -381,7 +367,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -413,7 +399,7 @@
             if(ifNull(less(row_number, 25), 0), breakdown, 'Other') AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -470,7 +456,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -483,13 +469,14 @@
 # ---
 # name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.1
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -545,16 +532,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 0), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('finance')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -566,13 +549,14 @@
 # ---
 # name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.2
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -628,16 +612,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 1), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('finance')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -649,13 +629,14 @@
 # ---
 # name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.3
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -711,16 +692,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 0), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('technology')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -732,13 +709,14 @@
 # ---
 # name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.4
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'strict', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                       and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                      and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -794,16 +772,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 1), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('technology')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -813,243 +787,3 @@
                     allow_experimental_analyzer=1
   '''
 # ---
-# name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.5
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.6
-  '''
-  
-  SELECT aggregation_target AS actor_id
-  FROM
-    (SELECT aggregation_target,
-            steps,
-            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
-            avg(step_2_conversion_time) step_2_average_conversion_time_inner,
-            median(step_1_conversion_time) step_1_median_conversion_time_inner,
-            median(step_2_conversion_time) step_2_median_conversion_time_inner,
-            prop
-     FROM
-       (SELECT aggregation_target,
-               steps,
-               max(steps) over (PARTITION BY aggregation_target,
-                                             prop) as max_steps,
-                               step_1_conversion_time,
-                               step_2_conversion_time,
-                               prop
-        FROM
-          (SELECT *,
-                  if(latest_0 <= latest_1
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY
-                     AND latest_1 <= latest_2
-                     AND latest_2 <= latest_0 + INTERVAL 7 DAY, 3, if(latest_0 <= latest_1
-                                                                      AND latest_1 <= latest_0 + INTERVAL 7 DAY, 2, 1)) AS steps,
-                  if(isNotNull(latest_1)
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
-                  if(isNotNull(latest_2)
-                     AND latest_2 <= latest_1 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_1), toDateTime(latest_2)), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN 2 PRECEDING AND 2 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'sign up', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'play movie', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'buy', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (1=1) )))
-           WHERE step_0 = 1 ))
-     GROUP BY aggregation_target,
-              steps,
-              prop
-     HAVING steps = max(max_steps))
-  WHERE steps IN [1, 2, 3]
-    AND arrayFlatten(array(prop)) = arrayFlatten(array('technology'))
-  ORDER BY aggregation_target
-  LIMIT 100
-  OFFSET 0 SETTINGS max_ast_elements=1000000,
-                    max_expanded_ast_elements=1000000
-  '''
-# ---
-# name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.7
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestStrictFunnelGroupBreakdownUDF.test_funnel_breakdown_group.8
-  '''
-  
-  SELECT aggregation_target AS actor_id
-  FROM
-    (SELECT aggregation_target,
-            steps,
-            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
-            avg(step_2_conversion_time) step_2_average_conversion_time_inner,
-            median(step_1_conversion_time) step_1_median_conversion_time_inner,
-            median(step_2_conversion_time) step_2_median_conversion_time_inner,
-            prop
-     FROM
-       (SELECT aggregation_target,
-               steps,
-               max(steps) over (PARTITION BY aggregation_target,
-                                             prop) as max_steps,
-                               step_1_conversion_time,
-                               step_2_conversion_time,
-                               prop
-        FROM
-          (SELECT *,
-                  if(latest_0 <= latest_1
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY
-                     AND latest_1 <= latest_2
-                     AND latest_2 <= latest_0 + INTERVAL 7 DAY, 3, if(latest_0 <= latest_1
-                                                                      AND latest_1 <= latest_0 + INTERVAL 7 DAY, 2, 1)) AS steps,
-                  if(isNotNull(latest_1)
-                     AND latest_1 <= latest_0 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_0), toDateTime(latest_1)), NULL) step_1_conversion_time,
-                  if(isNotNull(latest_2)
-                     AND latest_2 <= latest_1 + INTERVAL 7 DAY, dateDiff('second', toDateTime(latest_1), toDateTime(latest_2)), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN 2 PRECEDING AND 2 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'sign up', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'play movie', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'buy', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (1=1) )))
-           WHERE step_0 = 1 ))
-     GROUP BY aggregation_target,
-              steps,
-              prop
-     HAVING steps = max(max_steps))
-  WHERE steps IN [2, 3]
-    AND arrayFlatten(array(prop)) = arrayFlatten(array('technology'))
-  ORDER BY aggregation_target
-  LIMIT 100
-  OFFSET 0 SETTINGS max_ast_elements=1000000,
-                    max_expanded_ast_elements=1000000
-  '''
-# ---
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors.ambr
index e735153b628c3..642b651f50faf 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors.ambr
@@ -1,12 +1,13 @@
 # serializer version: 1
 # name: TestFunnelTrendsActors.test_funnel_trend_persons_returns_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            step_1_matching_events AS matching_events
+            step_1_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                toStartOfDay(timestamp) AS entrance_period_start,
@@ -140,15 +141,11 @@
                  entrance_period_start)
      WHERE ifNull(greaterOrEquals(steps_completed, 2), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -174,12 +171,13 @@
 # ---
 # name: TestFunnelTrendsActors.test_funnel_trend_persons_with_drop_off
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            final_matching_events AS matching_events
+            final_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                toStartOfDay(timestamp) AS entrance_period_start,
@@ -313,15 +311,11 @@
                  entrance_period_start)
      WHERE and(ifNull(greaterOrEquals(steps_completed, 1), 0), ifNull(less(steps_completed, 3), 0))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -347,12 +341,13 @@
 # ---
 # name: TestFunnelTrendsActors.test_funnel_trend_persons_with_no_to_step
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            final_matching_events AS matching_events
+            final_matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                toStartOfDay(timestamp) AS entrance_period_start,
@@ -486,15 +481,11 @@
                  entrance_period_start)
      WHERE ifNull(greaterOrEquals(steps_completed, 3), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors_udf.ambr
index cb4021c05d56d..d078ffbc040d7 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_actors_udf.ambr
@@ -1,15 +1,16 @@
 # serializer version: 1
 # name: TestFunnelTrendsActorsUDF.test_funnel_trend_persons_returns_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matching_events AS matching_events
+            matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), toUInt64(toDateTime(toStartOfDay(timestamp), 'UTC')), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_trends_v3(0, 2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
+               arrayJoin(aggregate_funnel_array_trends_v4(0, 2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
                                                                                                                                                                                                        and isNull(x_before.5)), ifNull(equals(x.5, x_after.5), isNull(x.5)
                                                                                                                                                                                                                                        and isNull(x_after.5)), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
@@ -42,16 +43,12 @@
         GROUP BY aggregation_target SETTINGS date_time_output_format='iso',
                                              date_time_input_format='best_effort')
      WHERE and(ifNull(equals(success_bool, 1), 0), ifNull(equals(entrance_period_start, toDateTime64('2021-05-01 00:00:00.000000', 6, 'UTC')), 0))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -77,15 +74,16 @@
 # ---
 # name: TestFunnelTrendsActorsUDF.test_funnel_trend_persons_with_drop_off
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matching_events AS matching_events
+            matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), toUInt64(toDateTime(toStartOfDay(timestamp), 'UTC')), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_trends_v3(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
+               arrayJoin(aggregate_funnel_array_trends_v4(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
                                                                                                                                                                                                        and isNull(x_before.5)), ifNull(equals(x.5, x_after.5), isNull(x.5)
                                                                                                                                                                                                                                        and isNull(x_after.5)), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
@@ -118,16 +116,12 @@
         GROUP BY aggregation_target SETTINGS date_time_output_format='iso',
                                              date_time_input_format='best_effort')
      WHERE and(ifNull(notEquals(success_bool, 1), 1), ifNull(equals(entrance_period_start, toDateTime64('2021-05-01 00:00:00.000000', 6, 'UTC')), 0))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -153,15 +147,16 @@
 # ---
 # name: TestFunnelTrendsActorsUDF.test_funnel_trend_persons_with_no_to_step
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            matching_events AS matching_events
+            matching_events AS matching_events,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), toUInt64(toDateTime(toStartOfDay(timestamp), 'UTC')), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_trends_v3(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
+               arrayJoin(aggregate_funnel_array_trends_v4(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
                                                                                                                                                                                                        and isNull(x_before.5)), ifNull(equals(x.5, x_after.5), isNull(x.5)
                                                                                                                                                                                                                                        and isNull(x_after.5)), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                                                                                       and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
@@ -194,16 +189,12 @@
         GROUP BY aggregation_target SETTINGS date_time_output_format='iso',
                                              date_time_input_format='best_effort')
      WHERE and(ifNull(equals(success_bool, 1), 0), ifNull(equals(entrance_period_start, toDateTime64('2021-05-01 00:00:00.000000', 6, 'UTC')), 0))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_udf.ambr
index b0b220a50a0bb..4a77813bdecd2 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_trends_udf.ambr
@@ -8,7 +8,7 @@
          data.breakdown AS prop
   FROM
     (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), toUInt64(toDateTime(toStartOfDay(timestamp), 'UTC')), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-            arrayJoin(aggregate_funnel_array_trends_v3(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
+            arrayJoin(aggregate_funnel_array_trends_v4(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
                                                                                                                                                                                                     and isNull(x_before.5)), ifNull(equals(x.5, x_after.5), isNull(x.5)
                                                                                                                                                                                                                                     and isNull(x_after.5)), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                                                                                    and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
@@ -41,7 +41,7 @@
   GROUP BY entrance_period_start,
            data.breakdown
   ORDER BY entrance_period_start ASC
-  LIMIT 1000 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 1000 SETTINGS join_algorithm='auto',
                       readonly=2,
                       max_execution_time=60,
                       allow_experimental_object_type=1,
@@ -61,7 +61,7 @@
          data.breakdown AS prop
   FROM
     (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), toUInt64(toDateTime(toStartOfDay(timestamp), 'US/Pacific')), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-            arrayJoin(aggregate_funnel_array_trends_v3(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
+            arrayJoin(aggregate_funnel_array_trends_v4(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
                                                                                                                                                                                                     and isNull(x_before.5)), ifNull(equals(x.5, x_after.5), isNull(x.5)
                                                                                                                                                                                                                                     and isNull(x_after.5)), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                                                                                    and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
@@ -94,7 +94,7 @@
   GROUP BY entrance_period_start,
            data.breakdown
   ORDER BY entrance_period_start ASC
-  LIMIT 1000 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 1000 SETTINGS join_algorithm='auto',
                       readonly=2,
                       max_execution_time=60,
                       allow_experimental_object_type=1,
@@ -114,7 +114,7 @@
          data.breakdown AS prop
   FROM
     (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), toUInt64(toDateTime(toStartOfWeek(timestamp, 0), 'UTC')), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-            arrayJoin(aggregate_funnel_array_trends_v3(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
+            arrayJoin(aggregate_funnel_array_trends_v4(0, 3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.5), 1), 0), ifNull(equals(x.5, x_before.5), isNull(x.5)
                                                                                                                                                                                                     and isNull(x_before.5)), ifNull(equals(x.5, x_after.5), isNull(x.5)
                                                                                                                                                                                                                                     and isNull(x_after.5)), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                                                                                    and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
@@ -147,7 +147,7 @@
   GROUP BY entrance_period_start,
            data.breakdown
   ORDER BY entrance_period_start ASC
-  LIMIT 1000 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 1000 SETTINGS join_algorithm='auto',
                       readonly=2,
                       max_execution_time=60,
                       allow_experimental_object_type=1,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_udf.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_udf.ambr
index ea0939ad56226..14b3e38b2eb64 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_udf.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_udf.ambr
@@ -20,7 +20,7 @@
             breakdown AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 15, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 15, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                         and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                         and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                        and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -53,7 +53,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 100 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 100 SETTINGS join_algorithm='auto',
                      readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -66,15 +66,15 @@
 # ---
 # name: TestFOSSFunnelUDF.test_funnel_conversion_window_seconds.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 15, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 15, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                         and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                         and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                        and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -105,17 +105,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 1), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -155,7 +150,7 @@
             breakdown AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -188,7 +183,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 100 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 100 SETTINGS join_algorithm='auto',
                      readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -235,7 +230,7 @@
             breakdown AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -270,7 +265,7 @@
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 100 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 100 SETTINGS join_algorithm='auto',
                      readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -302,7 +297,7 @@
             breakdown AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -346,7 +341,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 100 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 100 SETTINGS join_algorithm='auto',
                      readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -359,15 +354,15 @@
 # ---
 # name: TestFOSSFunnelUDF.test_funnel_with_property_groups.1
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -409,17 +404,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 0), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -431,15 +421,15 @@
 # ---
 # name: TestFOSSFunnelUDF.test_funnel_with_property_groups.2
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -481,17 +471,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 1), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -503,15 +488,15 @@
 # ---
 # name: TestFOSSFunnelUDF.test_funnel_with_property_groups.3
   '''
-  SELECT persons.id,
-         persons.id AS id,
-         persons.created_at AS created_at,
+  SELECT source.id,
+         source.id AS id,
          1
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(3, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -553,17 +538,12 @@
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE ifNull(greaterOrEquals(step_reached, 2), 0)
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT argMax(toTimeZone(person.created_at, 'UTC'), person.version) AS created_at,
-            person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.created_at DESC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -598,7 +578,7 @@
             breakdown AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -633,7 +613,7 @@
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 100 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 100 SETTINGS join_algorithm='auto',
                      readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -660,7 +640,7 @@
             breakdown AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, [], arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', [[]], arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                              and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                              and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                             and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -692,7 +672,7 @@
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 100 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 100 SETTINGS join_algorithm='auto',
                      readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -719,11 +699,12 @@
             if(ifNull(less(row_number, 25), 0), breakdown, ['Other']) AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                             and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                             and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                            and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                            and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', groupUniqArrayIf(prop, ifNull(notEquals(prop, []), isNotNull(prop)
+                                                                                                                       or isNotNull([]))), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                                                                                                                                                                                                                                         and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
+                                                                                                                                                                                                                                                                         and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                        and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
                af_tuple.1 AS step_reached,
                plus(af_tuple.1, 1) AS steps,
                af_tuple.2 AS breakdown,
@@ -766,7 +747,7 @@
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -793,61 +774,45 @@
             if(ifNull(less(row_number, 25), 0), breakdown, ['Other']) AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'step_1', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                       and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'step_1', 'ordered', groupUniqArrayIf(prop_1, ifNull(notEquals(prop_1, []), isNotNull(prop_1)
+                                                                                                                    or isNotNull([]))), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                                                                                                                                                                                                                                      and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
+                                                                                                                                                                                                                                                                      and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                     and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                                                     and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
                af_tuple.1 AS step_reached,
                plus(af_tuple.1, 1) AS steps,
                af_tuple.2 AS breakdown,
                af_tuple.3 AS timings,
                aggregation_target AS aggregation_target
         FROM
-          (SELECT timestamp AS timestamp,
-                  aggregation_target AS aggregation_target,
-                  uuid AS uuid,
-                          `$session_id` AS `$session_id`,
-                          `$window_id` AS `$window_id`,
-                          step_0 AS step_0,
-                          step_1 AS step_1,
-                          prop_basic AS prop_basic,
-                          prop_0 AS prop_0,
-                          prop_1 AS prop_1,
-                          prop,
-                          prop_vals AS prop_vals,
-                          prop
-           FROM
-             (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp,
-                     if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target,
-                     e.uuid AS uuid,
-                     e.`$session_id` AS `$session_id`,
-                     e.`$window_id` AS `$window_id`,
-                     if(equals(e.event, 'sign up'), 1, 0) AS step_0,
-                     if(and(equals(e.event, 'buy'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$version'), ''), 'null'), '^"|"$', ''), 'xyz'), 0)), 1, 0) AS step_1,
-                     [ifNull(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$browser'), ''), 'null'), '^"|"$', '')), '')] AS prop_basic,
-                     if(ifNull(equals(step_0, 1), 0), prop_basic, []) AS prop_0,
-                     if(ifNull(equals(step_1, 1), 0), prop_basic, []) AS prop_1,
-                     prop_1 AS prop,
-                     groupUniqArray(prop) OVER (PARTITION BY aggregation_target) AS prop_vals
-              FROM events AS e
-              LEFT OUTER JOIN
-                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
-                        person_distinct_id_overrides.distinct_id AS distinct_id
-                 FROM person_distinct_id_overrides
-                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                 GROUP BY person_distinct_id_overrides.distinct_id
-                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
-              WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('buy', 'sign up'))), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0)))) ARRAY
-           JOIN prop_vals AS prop
-           WHERE ifNull(notEquals(prop, []), isNotNull(prop)
-                        or isNotNull([])))
+          (SELECT toTimeZone(e.timestamp, 'UTC') AS timestamp,
+                  if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id) AS aggregation_target,
+                  e.uuid AS uuid,
+                  e.`$session_id` AS `$session_id`,
+                  e.`$window_id` AS `$window_id`,
+                  if(equals(e.event, 'sign up'), 1, 0) AS step_0,
+                  if(and(equals(e.event, 'buy'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$version'), ''), 'null'), '^"|"$', ''), 'xyz'), 0)), 1, 0) AS step_1,
+                  [ifNull(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$browser'), ''), 'null'), '^"|"$', '')), '')] AS prop_basic,
+                  if(ifNull(equals(step_0, 1), 0), prop_basic, []) AS prop_0,
+                  if(ifNull(equals(step_1, 1), 0), prop_basic, []) AS prop_1,
+                  prop_1 AS prop,
+                  groupUniqArray(prop) OVER (PARTITION BY aggregation_target) AS prop_vals
+           FROM events AS e
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), and(and(greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-01 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), toDateTime64('2020-01-08 23:59:59.999999', 6, 'UTC'))), in(e.event, tuple('buy', 'sign up'))), or(ifNull(equals(step_0, 1), 0), ifNull(equals(step_1, 1), 0))))
         GROUP BY aggregation_target
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -874,11 +839,12 @@
             if(ifNull(less(row_number, 25), 0), breakdown, ['Other']) AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1)])))) AS events_array,
-               arrayJoin(aggregate_funnel_array_v3(2, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
-                                                                                                                                                                                                             and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
-                                                                                                                                                                                                                                             and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
-                                                                                                                                                                                                                                                                            and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
-                                                                                                                                                                                                                                                                                                            and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
+               arrayJoin(aggregate_funnel_array_v4(2, 1209600, 'first_touch', 'ordered', groupUniqArrayIf(prop, ifNull(notEquals(prop, []), isNotNull(prop)
+                                                                                                                       or isNotNull([]))), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+                                                                                                                                                                                                                                         and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
+                                                                                                                                                                                                                                                                         and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                        and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
+                                                                                                                                                                                                                                                                                                                                        and isNull(x_after.3)), ifNull(greater(x.1, x_before.1), 0), ifNull(less(x.1, x_after.1), 0))), events_array, arrayRotateRight(events_array, 1), arrayRotateLeft(events_array, 1)))) AS af_tuple,
                af_tuple.1 AS step_reached,
                plus(af_tuple.1, 1) AS steps,
                af_tuple.2 AS breakdown,
@@ -921,7 +887,7 @@
      GROUP BY breakdown
      ORDER BY step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -953,7 +919,7 @@
             if(ifNull(less(row_number, 25), 0), breakdown, 'Other') AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1003,7 +969,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -1035,7 +1001,7 @@
             if(ifNull(less(row_number, 25), 0), breakdown, 'Other') AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1085,7 +1051,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -1117,7 +1083,7 @@
             if(ifNull(less(row_number, 25), 0), breakdown, 'Other') AS final_prop
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1174,7 +1140,7 @@
      GROUP BY breakdown
      ORDER BY step_3 DESC, step_2 DESC, step_1 DESC)
   GROUP BY final_prop
-  LIMIT 26 SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge',
+  LIMIT 26 SETTINGS join_algorithm='auto',
                     readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
@@ -1187,13 +1153,14 @@
 # ---
 # name: TestFunnelGroupBreakdownUDF.test_funnel_breakdown_group.1
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1249,16 +1216,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 0), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('finance')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1270,13 +1233,14 @@
 # ---
 # name: TestFunnelGroupBreakdownUDF.test_funnel_breakdown_group.2
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1332,16 +1296,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 1), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('finance')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1353,13 +1313,14 @@
 # ---
 # name: TestFunnelGroupBreakdownUDF.test_funnel_breakdown_group.3
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1415,16 +1376,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 0), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('technology')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1436,13 +1393,14 @@
 # ---
 # name: TestFunnelGroupBreakdownUDF.test_funnel_breakdown_group.4
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT arraySort(t -> t.1, groupArray(tuple(accurateCastOrNull(timestamp, 'Float64'), uuid, prop, arrayFilter(x -> ifNull(notEquals(x, 0), 1), [multiply(1, step_0), multiply(2, step_1), multiply(3, step_2)])))) AS events_array,
-               arrayJoin(aggregate_funnel_v3(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
+               arrayJoin(aggregate_funnel_v4(3, 1209600, 'first_touch', 'ordered', groupUniqArray(prop), arrayFilter((x, x_before, x_after) -> not(and(ifNull(lessOrEquals(length(x.4), 1), 0), ifNull(equals(x.4, x_before.4), isNull(x.4)
                                                                                                                                                                                                        and isNull(x_before.4)), ifNull(equals(x.4, x_after.4), isNull(x.4)
                                                                                                                                                                                                                                        and isNull(x_after.4)), ifNull(equals(x.3, x_before.3), isNull(x.3)
                                                                                                                                                                                                                                                                       and isNull(x_before.3)), ifNull(equals(x.3, x_after.3), isNull(x.3)
@@ -1498,16 +1456,12 @@
         HAVING ifNull(greaterOrEquals(step_reached, 0), 0))
      WHERE and(ifNull(greaterOrEquals(step_reached, 1), 0), ifNull(equals(arrayFlatten(array(breakdown)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(breakdown)))
                                                                    and isNull(arrayFlatten(array('technology')))))
-     ORDER BY aggregation_target ASC SETTINGS join_algorithm='direct,parallel_hash,hash,full_sorting_merge') AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+     ORDER BY aggregation_target ASC SETTINGS join_algorithm='auto') AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered.ambr
index 3f5e9e4467e64..d33ab0746b287 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered.ambr
@@ -1221,10 +1221,11 @@
 # ---
 # name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.1
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -1463,15 +1464,11 @@
      WHERE and(ifNull(in(steps, [1, 2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(prop)))
                                                        and isNull(arrayFlatten(array('finance')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1481,589 +1478,13 @@
                     allow_experimental_analyzer=1
   '''
 # ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.10
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.11
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.12
-  '''
-  
-  SELECT aggregation_target AS actor_id
-  FROM
-    (SELECT aggregation_target,
-            steps,
-            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
-            avg(step_2_conversion_time) step_2_average_conversion_time_inner,
-            median(step_1_conversion_time) step_1_median_conversion_time_inner,
-            median(step_2_conversion_time) step_2_median_conversion_time_inner,
-            prop
-     FROM
-       (SELECT aggregation_target,
-               steps,
-               max(steps) over (PARTITION BY aggregation_target,
-                                             prop) as max_steps,
-                               step_1_conversion_time,
-                               step_2_conversion_time,
-                               prop
-        FROM
-          (SELECT *,
-                  arraySort([latest_0,latest_1,latest_2]) as event_times,
-                  arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                  arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                  if(isNotNull(conversion_times[2])
-                     AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                  if(isNotNull(conversion_times[3])
-                     AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'sign up', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'play movie', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'buy', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1
-           UNION ALL SELECT *,
-                            arraySort([latest_0,latest_1,latest_2]) as event_times,
-                            arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                            arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                            if(isNotNull(conversion_times[2])
-                               AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                            if(isNotNull(conversion_times[3])
-                               AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'play movie', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'buy', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'sign up', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1
-           UNION ALL SELECT *,
-                            arraySort([latest_0,latest_1,latest_2]) as event_times,
-                            arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                            arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                            if(isNotNull(conversion_times[2])
-                               AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                            if(isNotNull(conversion_times[3])
-                               AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'buy', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'sign up', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'play movie', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1 ))
-     GROUP BY aggregation_target,
-              steps,
-              prop
-     HAVING steps = max(max_steps))
-  WHERE steps IN [1, 2, 3]
-    AND arrayFlatten(array(prop)) = arrayFlatten(array('technology'))
-  ORDER BY aggregation_target
-  LIMIT 100
-  OFFSET 0 SETTINGS max_ast_elements=1000000,
-                    max_expanded_ast_elements=1000000
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.13
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.14
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.15
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.16
-  '''
-  
-  SELECT aggregation_target AS actor_id
-  FROM
-    (SELECT aggregation_target,
-            steps,
-            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
-            avg(step_2_conversion_time) step_2_average_conversion_time_inner,
-            median(step_1_conversion_time) step_1_median_conversion_time_inner,
-            median(step_2_conversion_time) step_2_median_conversion_time_inner,
-            prop
-     FROM
-       (SELECT aggregation_target,
-               steps,
-               max(steps) over (PARTITION BY aggregation_target,
-                                             prop) as max_steps,
-                               step_1_conversion_time,
-                               step_2_conversion_time,
-                               prop
-        FROM
-          (SELECT *,
-                  arraySort([latest_0,latest_1,latest_2]) as event_times,
-                  arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                  arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                  if(isNotNull(conversion_times[2])
-                     AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                  if(isNotNull(conversion_times[3])
-                     AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'sign up', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'play movie', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'buy', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1
-           UNION ALL SELECT *,
-                            arraySort([latest_0,latest_1,latest_2]) as event_times,
-                            arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                            arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                            if(isNotNull(conversion_times[2])
-                               AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                            if(isNotNull(conversion_times[3])
-                               AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'play movie', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'buy', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'sign up', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1
-           UNION ALL SELECT *,
-                            arraySort([latest_0,latest_1,latest_2]) as event_times,
-                            arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                            arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                            if(isNotNull(conversion_times[2])
-                               AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                            if(isNotNull(conversion_times[3])
-                               AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'buy', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'sign up', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'play movie', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1 ))
-     GROUP BY aggregation_target,
-              steps,
-              prop
-     HAVING steps = max(max_steps))
-  WHERE steps IN [2, 3]
-    AND arrayFlatten(array(prop)) = arrayFlatten(array('technology'))
-  ORDER BY aggregation_target
-  LIMIT 100
-  OFFSET 0 SETTINGS max_ast_elements=1000000,
-                    max_expanded_ast_elements=1000000
-  '''
-# ---
 # name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.2
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -2302,15 +1723,11 @@
      WHERE and(ifNull(in(steps, [2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('finance'))), isNull(arrayFlatten(array(prop)))
                                                     and isNull(arrayFlatten(array('finance')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2322,10 +1739,11 @@
 # ---
 # name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.3
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -2564,15 +1982,11 @@
      WHERE and(ifNull(in(steps, [1, 2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(prop)))
                                                        and isNull(arrayFlatten(array('technology')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2584,10 +1998,11 @@
 # ---
 # name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.4
   '''
-  SELECT persons.id,
-         persons.id AS id
+  SELECT source.id,
+         source.id AS id
   FROM
-    (SELECT aggregation_target AS actor_id
+    (SELECT aggregation_target AS actor_id,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -2826,15 +2241,11 @@
      WHERE and(ifNull(in(steps, [2, 3]), 0), ifNull(equals(arrayFlatten(array(prop)), arrayFlatten(array('technology'))), isNull(arrayFlatten(array(prop)))
                                                     and isNull(arrayFlatten(array('technology')))))
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2844,326 +2255,3 @@
                     allow_experimental_analyzer=1
   '''
 # ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.5
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.6
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.7
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.8
-  '''
-  
-  SELECT aggregation_target AS actor_id
-  FROM
-    (SELECT aggregation_target,
-            steps,
-            avg(step_1_conversion_time) step_1_average_conversion_time_inner,
-            avg(step_2_conversion_time) step_2_average_conversion_time_inner,
-            median(step_1_conversion_time) step_1_median_conversion_time_inner,
-            median(step_2_conversion_time) step_2_median_conversion_time_inner,
-            prop
-     FROM
-       (SELECT aggregation_target,
-               steps,
-               max(steps) over (PARTITION BY aggregation_target,
-                                             prop) as max_steps,
-                               step_1_conversion_time,
-                               step_2_conversion_time,
-                               prop
-        FROM
-          (SELECT *,
-                  arraySort([latest_0,latest_1,latest_2]) as event_times,
-                  arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                  arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                  if(isNotNull(conversion_times[2])
-                     AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                  if(isNotNull(conversion_times[3])
-                     AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'sign up', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'play movie', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'buy', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1
-           UNION ALL SELECT *,
-                            arraySort([latest_0,latest_1,latest_2]) as event_times,
-                            arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                            arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                            if(isNotNull(conversion_times[2])
-                               AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                            if(isNotNull(conversion_times[3])
-                               AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'play movie', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'buy', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'sign up', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1
-           UNION ALL SELECT *,
-                            arraySort([latest_0,latest_1,latest_2]) as event_times,
-                            arraySum([if(latest_0 < latest_1 AND latest_1 <= latest_0 + INTERVAL 7 DAY, 1, 0),if(latest_0 < latest_2 AND latest_2 <= latest_0 + INTERVAL 7 DAY, 1, 0), 1]) AS steps ,
-                            arraySort([latest_0,latest_1,latest_2]) as conversion_times,
-                            if(isNotNull(conversion_times[2])
-                               AND conversion_times[2] <= conversion_times[1] + INTERVAL 7 DAY, dateDiff('second', conversion_times[1], conversion_times[2]), NULL) step_1_conversion_time,
-                            if(isNotNull(conversion_times[3])
-                               AND conversion_times[3] <= conversion_times[2] + INTERVAL 7 DAY, dateDiff('second', conversion_times[2], conversion_times[3]), NULL) step_2_conversion_time
-           FROM
-             (SELECT aggregation_target, timestamp, step_0,
-                                                    latest_0,
-                                                    step_1,
-                                                    min(latest_1) over (PARTITION by aggregation_target,
-                                                                                     prop
-                                                                        ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_1,
-                                                                       step_2,
-                                                                       min(latest_2) over (PARTITION by aggregation_target,
-                                                                                                        prop
-                                                                                           ORDER BY timestamp DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 0 PRECEDING) latest_2 ,
-                                                                                          if(has(['technology', 'finance'], prop), prop, 'Other') as prop
-              FROM
-                (SELECT *,
-                        prop_vals as prop
-                 FROM
-                   (SELECT e.timestamp as timestamp,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as aggregation_target,
-                           if(notEmpty(pdi.distinct_id), pdi.person_id, e.person_id) as person_id,
-                           if(event = 'buy', 1, 0) as step_0,
-                           if(step_0 = 1, timestamp, null) as latest_0,
-                           if(event = 'sign up', 1, 0) as step_1,
-                           if(step_1 = 1, timestamp, null) as latest_1,
-                           if(event = 'play movie', 1, 0) as step_2,
-                           if(step_2 = 1, timestamp, null) as latest_2,
-                           replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS prop_basic,
-                           prop_basic as prop,
-                           argMinIf(prop, timestamp, isNotNull(prop)) over (PARTITION by aggregation_target) as prop_vals
-                    FROM events e
-                    LEFT OUTER JOIN
-                      (SELECT distinct_id,
-                              argMax(person_id, version) as person_id
-                       FROM person_distinct_id2
-                       WHERE team_id = 99999
-                         AND distinct_id IN
-                           (SELECT distinct_id
-                            FROM events
-                            WHERE team_id = 99999
-                              AND event IN ['buy', 'play movie', 'sign up']
-                              AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                              AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC') )
-                       GROUP BY distinct_id
-                       HAVING argMax(is_deleted, version) = 0) AS pdi ON e.distinct_id = pdi.distinct_id
-                    LEFT JOIN
-                      (SELECT group_key,
-                              argMax(group_properties, _timestamp) AS group_properties_0
-                       FROM groups
-                       WHERE team_id = 99999
-                         AND group_type_index = 0
-                       GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-                    WHERE team_id = 99999
-                      AND event IN ['buy', 'play movie', 'sign up']
-                      AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-                      AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-                      AND (step_0 = 1
-                           OR step_1 = 1
-                           OR step_2 = 1) )))
-           WHERE step_0 = 1 ))
-     GROUP BY aggregation_target,
-              steps,
-              prop
-     HAVING steps = max(max_steps))
-  WHERE steps IN [2, 3]
-    AND arrayFlatten(array(prop)) = arrayFlatten(array('finance'))
-  ORDER BY aggregation_target
-  LIMIT 100
-  OFFSET 0 SETTINGS max_ast_elements=1000000,
-                    max_expanded_ast_elements=1000000
-  '''
-# ---
-# name: TestUnorderedFunnelGroupBreakdown.test_funnel_breakdown_group.9
-  '''
-  
-  SELECT replaceRegexpAll(JSONExtractRaw(group_properties_0, 'industry'), '^"|"$', '') AS value,
-         count(*) as count
-  FROM events e
-  LEFT JOIN
-    (SELECT group_key,
-            argMax(group_properties, _timestamp) AS group_properties_0
-     FROM groups
-     WHERE team_id = 99999
-       AND group_type_index = 0
-     GROUP BY group_key) groups_0 ON "$group_0" == groups_0.group_key
-  WHERE team_id = 99999
-    AND event IN ['buy', 'play movie', 'sign up']
-    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2020-01-01 00:00:00', 'UTC')
-    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-08 23:59:59', 'UTC')
-  GROUP BY value
-  ORDER BY count DESC, value DESC
-  LIMIT 26
-  OFFSET 0
-  '''
-# ---
diff --git a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered_persons.ambr b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered_persons.ambr
index a4bfbc566ff43..c4529bac0f50e 100644
--- a/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered_persons.ambr
+++ b/posthog/hogql_queries/insights/funnels/test/__snapshots__/test_funnel_unordered_persons.ambr
@@ -1,12 +1,13 @@
 # serializer version: 1
 # name: TestFunnelUnorderedStepsPersons.test_unordered_funnel_does_not_return_recordings
   '''
-  SELECT persons.id,
-         persons.id AS id,
+  SELECT source.id,
+         source.id AS id,
          source.matching_events AS matching_events
   FROM
     (SELECT aggregation_target AS actor_id,
-            array() AS matching_events
+            array() AS matching_events,
+            actor_id AS id
      FROM
        (SELECT aggregation_target AS aggregation_target,
                steps AS steps,
@@ -258,15 +259,11 @@
                       and isNull(max(max_steps))))
      WHERE ifNull(in(steps, [1, 2, 3]), 0)
      ORDER BY aggregation_target ASC) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE equals(person.team_id, 99999)
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/funnels/test/test_funnel.py b/posthog/hogql_queries/insights/funnels/test/test_funnel.py
index b92891822cb87..4cccf2c54414a 100644
--- a/posthog/hogql_queries/insights/funnels/test/test_funnel.py
+++ b/posthog/hogql_queries/insights/funnels/test/test_funnel.py
@@ -43,7 +43,7 @@
     FunnelsFilter,
     FunnelsQuery,
     HogQLQueryModifiers,
-    InsightDateRange,
+    DateRange,
     PersonsOnEventsMode,
     PropertyOperator,
     FunnelMathType,
@@ -3935,7 +3935,7 @@ def test_parses_breakdowns_correctly(self):
 
             query = FunnelsQuery(
                 series=[EventsNode(event="$pageview"), EventsNode(event="$pageview")],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -3968,7 +3968,7 @@ def test_funnel_parses_event_names_correctly(self):
 
             query = FunnelsQuery(
                 series=[EventsNode(event="test'1"), EventsNode()],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4026,7 +4026,7 @@ def test_time_to_convert_funnel_ignores_breakdown(self):
 
             query = FunnelsQuery(
                 series=[EventsNode(event="a"), EventsNode(event="b")],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4066,7 +4066,7 @@ def test_first_time_for_user_funnel_basic(self):
                     EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER),
                     EventsNode(event="$pageview"),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4081,7 +4081,7 @@ def test_first_time_for_user_funnel_basic(self):
                     EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER),
                     EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4148,7 +4148,7 @@ def test_first_time_for_user_funnel_with_actions(self):
                     ActionsNode(id=action_credit_card.pk),
                     ActionsNode(id=action_play_movie.pk, math=BaseMathType.FIRST_TIME_FOR_USER),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="-14d",
                 ),
             )
@@ -4252,7 +4252,7 @@ def test_first_time_for_user_funnel_filters(self):
                     EventsNode(event="$pageview"),
                     EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4273,7 +4273,7 @@ def test_first_time_for_user_funnel_filters(self):
                     ),
                     EventsNode(event="$pageview"),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4344,7 +4344,7 @@ def test_first_time_for_user_funnel_multiple_ids(self):
                     EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER),
                     EventsNode(event="$pageview"),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4359,7 +4359,7 @@ def test_first_time_for_user_funnel_multiple_ids(self):
                     EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER),
                     EventsNode(event="$pageview"),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2023-03-22",
                     date_to="2024-03-22",
                 ),
@@ -4414,7 +4414,7 @@ def test_first_time_for_user_funnel_person_properties(self):
                     ),
                     EventsNode(event="event2"),
                 ],
-                dateRange=InsightDateRange(
+                dateRange=DateRange(
                     date_from="2024-03-20",
                     date_to="2024-03-24",
                 ),
@@ -4429,6 +4429,20 @@ def test_first_time_for_user_funnel_person_properties(self):
             # classic and udf funnels handle no events differently
             assert len(results) == 0 or results[0]["count"] == 0
 
+            _create_event(
+                team=self.team,
+                event="event2",
+                distinct_id="user_1",
+                timestamp="2024-03-19T13:00:00Z",
+                properties={"property": "woah"},
+            )
+            query.series[0].math = FunnelMathType.FIRST_TIME_FOR_USER_WITH_FILTERS
+            assert query.dateRange is not None
+            query.dateRange.date_from = "2024-03-19"
+            results = FunnelsQueryRunner(query=query, team=self.team).calculate().results
+            self.assertEqual(results[0]["count"], 1)
+            self.assertEqual(results[1]["count"], 1)
+
         def test_funnel_personless_events_are_supported(self):
             user_id = uuid.uuid4()
             _create_event(
@@ -4448,7 +4462,7 @@ def test_funnel_personless_events_are_supported(self):
 
             query = FunnelsQuery(
                 series=[EventsNode(event="$pageview"), EventsNode(event="sign up")],
-                dateRange=InsightDateRange(date_from="2024-03-22", date_to="2024-03-22"),
+                dateRange=DateRange(date_from="2024-03-22", date_to="2024-03-22"),
             )
             results = FunnelsQueryRunner(query=query, team=self.team).calculate().results
 
@@ -4576,6 +4590,95 @@ def test_excluded_completion(self):
                 self.assertEqual(0, results[0]["count"])
                 self.assertEqual(0, results[1]["count"])
 
+        def test_breakdown_step_attributions(self):
+            events = [
+                {
+                    "event": "step one",
+                    "properties": {"$browser": "Chrome"},
+                    "timestamp": datetime(2021, 5, 1, 0, 0, 0),
+                },
+                {
+                    "event": "step two",
+                    "timestamp": datetime(2021, 5, 1, 0, 0, 1),
+                    "properties": {"$browser": "Safari"},
+                },
+                {
+                    "event": "step two",
+                    "timestamp": datetime(2021, 5, 1, 0, 0, 2),
+                    "properties": {"$browser": "Chrome"},
+                },
+                {
+                    "event": "step three",
+                    "timestamp": datetime(2021, 5, 1, 0, 0, 3),
+                    "properties": {"$browser": "Chrome"},
+                },
+            ]
+
+            journeys_for(
+                {
+                    "user_one": events,
+                },
+                self.team,
+            )
+
+            filters = {
+                "insight": INSIGHT_FUNNELS,
+                "funnel_viz_type": "steps",
+                "date_from": "2021-05-01 00:00:00",
+                "date_to": "2021-05-02 23:59:59",
+                "funnel_window_interval": 30,
+                "funnel_window_interval_unit": "second",
+                "events": [
+                    {"id": "step one", "order": 0},
+                    {"id": "step two", "order": 1},
+                    {"id": "step three", "order": 2},
+                ],
+                "breakdown_type": "event",
+                "breakdown": "$browser",
+            }
+
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+            assert 1 == len(results)
+            result = results[0]
+            assert 3 == len(result)
+            assert [x["count"] == 1 for x in result]
+            assert [x["breakdown"] == ["Chrome"] for x in result]
+
+            filters["breakdown_attribution_type"] = "all_events"
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+            assert 1 == len(results)
+            result = results[0]
+            assert [x["count"] for x in result] == [1, 1, 1]
+            assert [x["breakdown"] == ["Chrome"] for x in result]
+
+            filters["breakdown_attribution_type"] = "step"
+            filters["breakdown_attribution_value"] = 0
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+            assert 1 == len(results)
+            result = results[0]
+            assert [x["count"] for x in result] == [1, 1, 1]
+            assert [x["breakdown"] == ["Chrome"] for x in result]
+
+            filters["breakdown_attribution_type"] = "step"
+            filters["breakdown_attribution_value"] = 1
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+            assert 2 == len(results)
+            for result in results:
+                assert [x["count"] for x in result] == [1, 1, 1]
+
+            filters["breakdown_attribution_type"] = "step"
+            filters["breakdown_attribution_value"] = 2
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+            assert 1 == len(results)
+            result = results[0]
+            assert [x["count"] for x in result] == [1, 1, 1]
+            assert [x["breakdown"] == ["Chrome"] for x in result]
+
     return TestGetFunnel
 
 
diff --git a/posthog/hogql_queries/insights/funnels/test/test_funnel_aggregation_operations.py b/posthog/hogql_queries/insights/funnels/test/test_funnel_aggregation_operations.py
index 1049b487ebcbb..5cfef9b468674 100644
--- a/posthog/hogql_queries/insights/funnels/test/test_funnel_aggregation_operations.py
+++ b/posthog/hogql_queries/insights/funnels/test/test_funnel_aggregation_operations.py
@@ -8,7 +8,7 @@
 from posthog.hogql.parser import parse_expr
 from posthog.hogql_queries.insights.funnels.funnel_aggregation_operations import FirstTimeForUserAggregationQuery
 from posthog.hogql_queries.insights.funnels.funnel_query_context import FunnelQueryContext
-from posthog.schema import EventsNode, FunnelsFilter, FunnelsQuery, InsightDateRange
+from posthog.schema import EventsNode, FunnelsFilter, FunnelsQuery, DateRange
 from posthog.test.base import APIBaseTest, ClickhouseTestMixin
 
 
@@ -17,7 +17,7 @@ def test_first_time_for_user_aggregation_outer_query(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
         )
         ctx = FunnelQueryContext(funnels_query, self.team)
         filters = parse_expr("1 = 1")
@@ -35,7 +35,7 @@ def test_first_time_for_user_aggregation_query_select(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
         )
 
         with freeze_time("2024-07-31"):
@@ -88,7 +88,7 @@ def test_first_time_for_user_aggregation_query_filter(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
         )
 
         with freeze_time("2024-07-31"):
@@ -115,7 +115,7 @@ def test_first_time_for_user_aggregation_query_no_filters(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
         )
 
         with freeze_time("2024-07-31"):
@@ -143,7 +143,7 @@ def test_first_time_for_user_aggregation_query_group_by(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
         )
         ctx = FunnelQueryContext(funnels_query, self.team)
 
@@ -161,7 +161,7 @@ def test_first_time_for_user_aggregation_query_having(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
         )
         ctx = FunnelQueryContext(funnels_query, self.team)
 
@@ -183,7 +183,7 @@ def test_first_time_for_user_aggregation_query_sampling_factor(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
             samplingFactor=0.1,
         )
         ctx = FunnelQueryContext(funnels_query, self.team)
@@ -202,7 +202,7 @@ def test_first_time_for_user_aggregation_query_select_from(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="$pageview")],
             funnelsFilter=FunnelsFilter(funnelWindowInterval=14),
-            dateRange=InsightDateRange(date_from="-14d"),
+            dateRange=DateRange(date_from="-14d"),
         )
         ctx = FunnelQueryContext(funnels_query, self.team)
 
diff --git a/posthog/hogql_queries/insights/funnels/test/test_funnel_trends.py b/posthog/hogql_queries/insights/funnels/test/test_funnel_trends.py
index 5dc01e90fa1a4..2bf698a26ffc5 100644
--- a/posthog/hogql_queries/insights/funnels/test/test_funnel_trends.py
+++ b/posthog/hogql_queries/insights/funnels/test/test_funnel_trends.py
@@ -2342,6 +2342,205 @@ def test_excluded_completion(self):
         self.assertEqual(0, results[0]["reached_from_step_count"])
         self.assertEqual(0, results[0]["reached_to_step_count"])
 
+    def test_breakdown_with_attribution(self):
+        events = [
+            {
+                "event": "step one",
+                "properties": {"$browser": "Chrome"},
+                "timestamp": datetime(2021, 5, 1, 0, 0, 0),
+            },
+            {
+                "event": "step one",
+                "properties": {"$browser": "Safari"},
+                "timestamp": datetime(2021, 5, 1, 0, 0, 1),
+            },
+            {
+                "event": "step two",
+                "timestamp": datetime(2021, 5, 1, 0, 0, 14),
+                "properties": {"$browser": "Chrome"},
+            },
+            {
+                "event": "step one",
+                "properties": {"$browser": "Chrome"},
+                "timestamp": datetime(2021, 5, 2, 0, 0, 0),
+            },
+            {
+                "event": "step two",
+                "properties": {"$browser": "Safari"},
+                "timestamp": datetime(2021, 5, 2, 0, 0, 1),
+            },
+            {
+                "event": "step two",
+                "timestamp": datetime(2021, 5, 2, 0, 0, 14),
+                "properties": {"$browser": "Chrome"},
+            },
+        ]
+        journeys_for(
+            {
+                "user_one": events,
+            },
+            self.team,
+        )
+
+        filters = {
+            "insight": INSIGHT_FUNNELS,
+            "funnel_viz_type": "trends",
+            "interval": "day",
+            "date_from": "2021-05-01 00:00:00",
+            "date_to": "2021-05-02 23:59:59",
+            "funnel_window_interval": 30,
+            "funnel_window_interval_unit": "second",
+            "events": [
+                {"id": "step one", "order": 0},
+                {"id": "step two", "order": 1},
+            ],
+            "breakdown_type": "event",
+            "breakdown": "$browser",
+        }
+
+        query = cast(FunnelsQuery, filter_to_query(filters))
+        results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+
+        assert 2 == len(results)
+        assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+        assert [1, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+
+        filters["breakdown_attribution_type"] = "all_events"
+        query = cast(FunnelsQuery, filter_to_query(filters))
+        results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+
+        assert 4 == len(results)
+        assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+        assert [1, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+        assert [1, 0] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+        assert [0, 0] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+
+        filters["breakdown_attribution_type"] = "step"
+        filters["breakdown_attribution_value"] = 0
+        query = cast(FunnelsQuery, filter_to_query(filters))
+        full_results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate()
+        results = full_results.results
+
+        # Normal funnels fail on this
+        if full_results.isUdf:
+            assert 4 == len(results)
+            assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [1, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [1, 0] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+            assert [1, 0] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+
+            filters["breakdown_attribution_type"] = "step"
+            filters["breakdown_attribution_value"] = 1
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+
+            assert 4 == len(results)
+            assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [1, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+            assert [0, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+
+    def test_breakdown_with_attribution_2(self):
+        events = [
+            {
+                "event": "step one",
+                "properties": {"$browser": "Chrome"},
+                "timestamp": datetime(2021, 5, 1, 0, 0, 0),
+            },
+            {
+                "event": "step two",
+                "timestamp": datetime(2021, 5, 1, 0, 0, 1),
+                "properties": {"$browser": "Chrome"},
+            },
+            {
+                "event": "step three",
+                "timestamp": datetime(2021, 5, 1, 0, 0, 2),
+                "properties": {"$browser": "Safari"},
+            },
+            {
+                "event": "step one",
+                "properties": {"$browser": "Safari"},
+                "timestamp": datetime(2021, 5, 2, 0, 0, 0),
+            },
+            {
+                "event": "step two",
+                "timestamp": datetime(2021, 5, 2, 0, 0, 1),
+                "properties": {"$browser": "Safari"},
+            },
+            {
+                "event": "step three",
+                "timestamp": datetime(2021, 5, 2, 0, 0, 2),
+                "properties": {"$browser": "Chrome"},
+            },
+        ]
+
+        journeys_for(
+            {
+                "user_one": events,
+            },
+            self.team,
+        )
+
+        filters = {
+            "insight": INSIGHT_FUNNELS,
+            "funnel_viz_type": "trends",
+            "interval": "day",
+            "date_from": "2021-05-01 00:00:00",
+            "date_to": "2021-05-02 23:59:59",
+            "funnel_window_interval": 30,
+            "funnel_window_interval_unit": "second",
+            "events": [
+                {"id": "step one", "order": 0},
+                {"id": "step two", "order": 1},
+                {"id": "step three", "order": 2},
+            ],
+            "breakdown_type": "event",
+            "breakdown": "$browser",
+            "funnel_from_step": 0,
+            "funnel_to_step": 2,
+        }
+
+        query = cast(FunnelsQuery, filter_to_query(filters))
+        results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+
+        assert 2 == len(results)
+        assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+        assert [1, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+
+        filters["breakdown_attribution_type"] = "all_events"
+        query = cast(FunnelsQuery, filter_to_query(filters))
+        results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+
+        assert 4 == len(results)
+        assert [1, 0] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+        assert [0, 0] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+        assert [0, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+        assert [0, 0] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+
+        filters["breakdown_attribution_type"] = "step"
+        filters["breakdown_attribution_value"] = 0
+        query = cast(FunnelsQuery, filter_to_query(filters))
+        full_results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate()
+        results = full_results.results
+
+        if full_results.isUdf:
+            assert 4 == len(results)
+            assert [1, 0] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [1, 0] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [0, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+            assert [0, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+
+            filters["breakdown_attribution_type"] = "step"
+            filters["breakdown_attribution_value"] = 2
+            query = cast(FunnelsQuery, filter_to_query(filters))
+            results = FunnelsQueryRunner(query=query, team=self.team, just_summarize=True).calculate().results
+
+            assert 4 == len(results)
+            assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [0, 1] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Chrome"]]
+            assert [1, 1] == [x["reached_from_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+            assert [1, 0] == [x["reached_to_step_count"] for x in results if x["breakdown_value"] == ["Safari"]]
+
 
 class TestFunnelTrends(BaseTestFunnelTrends):
     __test__ = True
diff --git a/posthog/hogql_queries/insights/funnels/test/test_funnel_trends_udf.py b/posthog/hogql_queries/insights/funnels/test/test_funnel_trends_udf.py
index 783bb30a53ab7..278344e75d714 100644
--- a/posthog/hogql_queries/insights/funnels/test/test_funnel_trends_udf.py
+++ b/posthog/hogql_queries/insights/funnels/test/test_funnel_trends_udf.py
@@ -17,7 +17,7 @@
     FunnelsFilter,
     FunnelVizType,
     BreakdownAttributionType,
-    InsightDateRange,
+    DateRange,
     IntervalType,
 )
 from posthog.test.base import _create_person, _create_event
@@ -120,7 +120,7 @@ def test_different_prop_val_in_strict_filter(self):
         funnels_query = FunnelsQuery(
             series=[EventsNode(event="first"), EventsNode(event="second")],
             breakdownFilter=BreakdownFilter(breakdown="bd"),
-            dateRange=InsightDateRange(date_from="2024-01-01", date_to="2024-01-08"),
+            dateRange=DateRange(date_from="2024-01-01", date_to="2024-01-08"),
             interval=IntervalType.DAY,
             funnelsFilter=FunnelsFilter(funnelOrderType=FunnelOrderType.STRICT, funnelVizType=FunnelVizType.TRENDS),
         )
diff --git a/posthog/hogql_queries/insights/test/__snapshots__/test_insight_actors_query_runner.ambr b/posthog/hogql_queries/insights/test/__snapshots__/test_insight_actors_query_runner.ambr
index b8db8df7c3613..b2a235c2308e0 100644
--- a/posthog/hogql_queries/insights/test/__snapshots__/test_insight_actors_query_runner.ambr
+++ b/posthog/hogql_queries/insights/test/__snapshots__/test_insight_actors_query_runner.ambr
@@ -66,7 +66,8 @@
                                                               WHERE equals(person.team_id, 99999)
                                                               GROUP BY person.id
                                                               HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'US/Pacific'), person.version), plus(now64(6, 'US/Pacific'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-     ORDER BY persons.properties___name ASC)
+     ORDER BY persons.properties___name ASC SETTINGS optimize_aggregation_in_order=1,
+                                                     join_algorithm='auto')
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -154,7 +155,8 @@
                                                                                                                           and isNull(toStartOfDay(parseDateTime64BestEffortOrNull('2020-01-12', 6, 'US/Pacific')))), ifNull(equals(status, 'returning'), 0))) AS source)))
                                                        GROUP BY person.id
                                                        HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'US/Pacific'), person.version), plus(now64(6, 'US/Pacific'), toIntervalDay(1))), 0))))) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-     ORDER BY persons.properties___name ASC)
+     ORDER BY persons.properties___name ASC SETTINGS optimize_aggregation_in_order=1,
+                                                     join_algorithm='auto')
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -192,7 +194,8 @@
         WHERE equals(groups.team_id, 99999)
         GROUP BY groups.group_type_index,
                  groups.group_key) AS groups ON equals(groups.key, source.group_key)
-     ORDER BY groups.properties___name ASC)
+     ORDER BY groups.properties___name ASC SETTINGS optimize_aggregation_in_order=1,
+                                                    join_algorithm='auto')
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -258,7 +261,8 @@
                                                                                                          WHERE ifNull(equals(num_intervals, 2), 0)) AS source)))
                                                        GROUP BY person.id
                                                        HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'US/Pacific'), person.version), plus(now64(6, 'US/Pacific'), toIntervalDay(1))), 0))))) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-     ORDER BY persons.properties___name ASC)
+     ORDER BY persons.properties___name ASC SETTINGS optimize_aggregation_in_order=1,
+                                                     join_algorithm='auto')
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -291,7 +295,8 @@
         WHERE equals(groups.team_id, 99999)
         GROUP BY groups.group_type_index,
                  groups.group_key) AS groups ON equals(groups.key, source.actor_id)
-     ORDER BY groups.properties___name ASC)
+     ORDER BY groups.properties___name ASC SETTINGS optimize_aggregation_in_order=1,
+                                                    join_algorithm='auto')
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -357,7 +362,8 @@
                                                           GROUP BY actor_id) AS source)))
         GROUP BY person.id
         HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'US/Pacific'), person.version), plus(now64(6, 'US/Pacific'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-     ORDER BY persons.properties___name ASC)
+     ORDER BY persons.properties___name ASC SETTINGS optimize_aggregation_in_order=1,
+                                                     join_algorithm='auto')
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
@@ -432,7 +438,8 @@
                                                                                                          GROUP BY actor_id) AS source)))
                                                        GROUP BY person.id
                                                        HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'US/Pacific'), person.version), plus(now64(6, 'US/Pacific'), toIntervalDay(1))), 0))))) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-     ORDER BY persons.properties___name ASC)
+     ORDER BY persons.properties___name ASC SETTINGS optimize_aggregation_in_order=1,
+                                                     join_algorithm='auto')
   LIMIT 100 SETTINGS readonly=2,
                      max_execution_time=60,
                      allow_experimental_object_type=1,
diff --git a/posthog/hogql_queries/insights/test/__snapshots__/test_paths_query_runner_ee.ambr b/posthog/hogql_queries/insights/test/__snapshots__/test_paths_query_runner_ee.ambr
index 20f2012034bba..1501ce23b7e9e 100644
--- a/posthog/hogql_queries/insights/test/__snapshots__/test_paths_query_runner_ee.ambr
+++ b/posthog/hogql_queries/insights/test/__snapshots__/test_paths_query_runner_ee.ambr
@@ -1163,11 +1163,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -1264,44 +1265,11 @@
      WHERE and(ifNull(equals(path_dropoff_key, '2_step two'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
                                                                          and isNull(path_key)))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(path_dropoff_key, '2_step two'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
-                                                                                                                           and isNull(path_key)))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1312,11 +1280,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -1412,43 +1381,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE ifNull(equals(path_key, '2_step two'), 0)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE ifNull(equals(path_key, '2_step two'), 0)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1459,11 +1396,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.2
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -1559,43 +1497,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_step two'), 0), 1)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_step two'), 0), 1)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1606,11 +1512,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.3
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -1707,44 +1614,11 @@
      WHERE and(ifNull(equals(path_dropoff_key, '3_step three'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
                                                                            and isNull(path_key)))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(path_dropoff_key, '3_step three'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
-                                                                                                                             and isNull(path_key)))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1755,11 +1629,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.4
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -1855,43 +1730,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE ifNull(equals(path_key, '3_step three'), 0)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE ifNull(equals(path_key, '3_step three'), 0)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1902,11 +1745,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.5
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -2002,43 +1846,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '3_step three'), 0), 1)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_step three'), 0), 1)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2049,11 +1861,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.6
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -2150,44 +1963,11 @@
      WHERE and(ifNull(equals(path_dropoff_key, '4_step four'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
                                                                           and isNull(path_key)))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(path_dropoff_key, '4_step four'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
-                                                                                                                            and isNull(path_key)))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2198,11 +1978,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.7
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -2298,43 +2079,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE ifNull(equals(path_key, '4_step four'), 0)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE ifNull(equals(path_key, '4_step four'), 0)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2345,11 +2094,12 @@
 # ---
 # name: ClickhousePathsUDF.test_person_dropoffs.8
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -2445,43 +2195,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '4_step four'), 0), 1)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '4_step four'), 0), 1)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2723,7 +2441,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -2890,7 +2610,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3043,7 +2765,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3208,7 +2932,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3383,7 +3109,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3577,11 +3305,12 @@
 # ---
 # name: ClickhousePathsUDF.test_start_and_end.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -3686,44 +3415,11 @@
            WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
      WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/5') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 5), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(5, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 5), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(5, 2)), [filtered_timings[plus(1, intDiv(5, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 5), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(5, 2)), [filtered_uuid[plus(1, intDiv(5, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 5), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(5, 2)), [filtered_timestamp[plus(1, intDiv(5, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 5), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(5, 2)), [filtered_session_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 5), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(5, 2)), [filtered_window_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -3821,11 +3517,12 @@
 # ---
 # name: ClickhousePathsUDF.test_start_and_end.3
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -3930,44 +3627,11 @@
            WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
      WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/2') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 4), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(4, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 4), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(4, 2)), [filtered_timings[plus(1, intDiv(4, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 4), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(4, 2)), [filtered_uuid[plus(1, intDiv(4, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 4), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(4, 2)), [filtered_timestamp[plus(1, intDiv(4, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 4), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(4, 2)), [filtered_session_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 4), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(4, 2)), [filtered_window_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4065,11 +3729,12 @@
 # ---
 # name: ClickhousePathsUDF.test_start_and_end_materialized.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -4174,44 +3839,11 @@
            WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
      WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/5') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 5), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(5, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 5), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(5, 2)), [filtered_timings[plus(1, intDiv(5, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 5), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(5, 2)), [filtered_uuid[plus(1, intDiv(5, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 5), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(5, 2)), [filtered_timestamp[plus(1, intDiv(5, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 5), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(5, 2)), [filtered_session_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 5), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(5, 2)), [filtered_window_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(nullIf(nullIf(events.`mat_$current_url`, ''), 'null'), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4309,11 +3941,12 @@
 # ---
 # name: ClickhousePathsUDF.test_start_and_end_materialized.3
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -4389,73 +4022,40 @@
                         groupArray(timestamp) AS timestamp_list,
                         groupArray(session_id) AS session_id_list,
                         groupArray(window_id) AS window_id_list
-                 FROM
-                   (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp,
-                           if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id,
-                           ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(nullIf(nullIf(events.`mat_$current_url`, ''), 'null'), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped,
-                           events.uuid AS uuid,
-                           toTimeZone(events.timestamp, 'UTC') AS timestamp,
-                           ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id,
-                           ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id,
-                           NULL AS groupings,
-                           multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index,
-                           (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                    FROM events
-                    LEFT OUTER JOIN
-                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
-                              person_distinct_id_overrides.distinct_id AS distinct_id
-                       FROM person_distinct_id_overrides
-                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                       GROUP BY person_distinct_id_overrides.distinct_id
-                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                 GROUP BY person_id) ARRAY
-              JOIN session_paths AS path_time_tuple,
-                   arrayEnumerate(session_paths) AS session_index) ARRAY
-           JOIN limited_path_timings AS joined_path_tuple,
-                arrayEnumerate(limited_path_timings) AS event_in_session_index
-           WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-     WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
-     GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/2') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 4), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(4, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 4), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(4, 2)), [filtered_timings[plus(1, intDiv(4, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 4), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(4, 2)), [filtered_uuid[plus(1, intDiv(4, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 4), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(4, 2)), [filtered_timestamp[plus(1, intDiv(4, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 4), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(4, 2)), [filtered_session_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 4), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(4, 2)), [filtered_window_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(nullIf(nullIf(events.`mat_$current_url`, ''), 'null'), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+                 FROM
+                   (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp,
+                           if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id,
+                           ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(nullIf(nullIf(events.`mat_$current_url`, ''), 'null'), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped,
+                           events.uuid AS uuid,
+                           toTimeZone(events.timestamp, 'UTC') AS timestamp,
+                           ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id,
+                           ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id,
+                           NULL AS groupings,
+                           multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index,
+                           (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
+                    FROM events
+                    LEFT OUTER JOIN
+                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                              person_distinct_id_overrides.distinct_id AS distinct_id
+                       FROM person_distinct_id_overrides
+                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                       GROUP BY person_distinct_id_overrides.distinct_id
+                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
+                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
+                 GROUP BY person_id) ARRAY
+              JOIN session_paths AS path_time_tuple,
+                   arrayEnumerate(session_paths) AS session_index) ARRAY
+           JOIN limited_path_timings AS joined_path_tuple,
+                arrayEnumerate(limited_path_timings) AS event_in_session_index
+           WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
+     WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
+     GROUP BY person_id) AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4713,11 +4313,12 @@
 # ---
 # name: ClickhousePathsUDF.test_step_limit.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -4813,43 +4414,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 2) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 2) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 2) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 2) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 2) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 2) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -4860,11 +4429,12 @@
 # ---
 # name: ClickhousePathsUDF.test_step_limit.2
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -4960,43 +4530,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 2) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 2) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 2) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 2) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 2) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 2) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5089,11 +4627,12 @@
 # ---
 # name: ClickhousePathsUDF.test_step_limit.4
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -5189,43 +4728,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 3) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 3) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 3) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 3) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 3) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 3) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5318,11 +4825,12 @@
 # ---
 # name: ClickhousePathsUDF.test_step_limit.6
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -5418,43 +4926,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 4) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 4) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 4) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 4) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 4) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 4) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5465,11 +4941,12 @@
 # ---
 # name: ClickhousePathsUDF.test_step_limit.7
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -5565,43 +5042,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 4) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 4) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 4) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 4) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 4) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 4) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -5612,11 +5057,12 @@
 # ---
 # name: ClickhousePathsUDF.test_step_limit.8
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -5689,66 +5135,34 @@
                            if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id,
                            ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped,
                            events.uuid AS uuid,
-                           toTimeZone(events.timestamp, 'UTC') AS timestamp,
-                           ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id,
-                           ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id,
-                           NULL AS groupings,
-                           multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index,
-                           (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                    FROM events
-                    LEFT OUTER JOIN
-                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
-                              person_distinct_id_overrides.distinct_id AS distinct_id
-                       FROM person_distinct_id_overrides
-                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                       GROUP BY person_distinct_id_overrides.distinct_id
-                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                 GROUP BY person_id) ARRAY
-              JOIN session_paths AS path_time_tuple,
-                   arrayEnumerate(session_paths) AS session_index) ARRAY
-           JOIN limited_path_timings AS joined_path_tuple,
-                arrayEnumerate(limited_path_timings) AS event_in_session_index))
-     WHERE and(ifNull(equals(last_path_key, '3_/3'), 0), ifNull(equals(path_key, '4_/4'), 0))
-     GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 4) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 4) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 4) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 4) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 4) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 4) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_/3'), 0), ifNull(equals(path_key, '4_/4'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+                           toTimeZone(events.timestamp, 'UTC') AS timestamp,
+                           ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id,
+                           ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id,
+                           NULL AS groupings,
+                           multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index,
+                           (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
+                    FROM events
+                    LEFT OUTER JOIN
+                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                              person_distinct_id_overrides.distinct_id AS distinct_id
+                       FROM person_distinct_id_overrides
+                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                       GROUP BY person_distinct_id_overrides.distinct_id
+                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
+                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
+                 GROUP BY person_id) ARRAY
+              JOIN session_paths AS path_time_tuple,
+                   arrayEnumerate(session_paths) AS session_index) ARRAY
+           JOIN limited_path_timings AS joined_path_tuple,
+                arrayEnumerate(limited_path_timings) AS event_in_session_index))
+     WHERE and(ifNull(equals(last_path_key, '3_/3'), 0), ifNull(equals(path_key, '4_/4'), 0))
+     GROUP BY person_id) AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -13017,11 +12431,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -13118,44 +12533,11 @@
      WHERE and(ifNull(equals(path_dropoff_key, '2_step two'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
                                                                          and isNull(path_key)))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(path_dropoff_key, '2_step two'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
-                                                                                                                           and isNull(path_key)))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -13166,11 +12548,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -13266,43 +12649,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE ifNull(equals(path_key, '2_step two'), 0)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE ifNull(equals(path_key, '2_step two'), 0)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -13313,11 +12664,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.2
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -13413,43 +12765,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_step two'), 0), 1)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_step two'), 0), 1)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -13460,11 +12780,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.3
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -13561,44 +12882,11 @@
      WHERE and(ifNull(equals(path_dropoff_key, '3_step three'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
                                                                            and isNull(path_key)))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(path_dropoff_key, '3_step three'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
-                                                                                                                             and isNull(path_key)))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -13609,11 +12897,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.4
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -13709,43 +12998,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE ifNull(equals(path_key, '3_step three'), 0)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE ifNull(equals(path_key, '3_step three'), 0)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -13756,11 +13013,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.5
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -13833,66 +13091,34 @@
                            if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id,
                            ifNull(events.event, '') AS path_item_ungrouped,
                            events.uuid AS uuid,
-                           toTimeZone(events.timestamp, 'UTC') AS timestamp,
-                           ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id,
-                           ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id,
-                           NULL AS groupings,
-                           multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index,
-                           (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                    FROM events
-                    LEFT OUTER JOIN
-                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
-                              person_distinct_id_overrides.distinct_id AS distinct_id
-                       FROM person_distinct_id_overrides
-                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                       GROUP BY person_distinct_id_overrides.distinct_id
-                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                 GROUP BY person_id) ARRAY
-              JOIN session_paths AS path_time_tuple,
-                   arrayEnumerate(session_paths) AS session_index) ARRAY
-           JOIN limited_path_timings AS joined_path_tuple,
-                arrayEnumerate(limited_path_timings) AS event_in_session_index))
-     WHERE and(ifNull(equals(last_path_key, '3_step three'), 0), 1)
-     GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_step three'), 0), 1)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+                           toTimeZone(events.timestamp, 'UTC') AS timestamp,
+                           ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id,
+                           ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id,
+                           NULL AS groupings,
+                           multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index,
+                           (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
+                    FROM events
+                    LEFT OUTER JOIN
+                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                              person_distinct_id_overrides.distinct_id AS distinct_id
+                       FROM person_distinct_id_overrides
+                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                       GROUP BY person_distinct_id_overrides.distinct_id
+                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
+                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
+                 GROUP BY person_id) ARRAY
+              JOIN session_paths AS path_time_tuple,
+                   arrayEnumerate(session_paths) AS session_index) ARRAY
+           JOIN limited_path_timings AS joined_path_tuple,
+                arrayEnumerate(limited_path_timings) AS event_in_session_index))
+     WHERE and(ifNull(equals(last_path_key, '3_step three'), 0), 1)
+     GROUP BY person_id) AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -13903,11 +13129,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.6
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -14004,44 +13231,11 @@
      WHERE and(ifNull(equals(path_dropoff_key, '4_step four'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
                                                                           and isNull(path_key)))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(path_dropoff_key, '4_step four'), 0), ifNull(equals(path_dropoff_key, path_key), isNull(path_dropoff_key)
-                                                                                                                            and isNull(path_key)))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -14052,11 +13246,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.7
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -14152,43 +13347,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE ifNull(equals(path_key, '4_step four'), 0)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE ifNull(equals(path_key, '4_step four'), 0)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -14199,11 +13362,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_person_dropoffs.8
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -14299,43 +13463,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '4_step four'), 0), 1)
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 5) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 5) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 5) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 5) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 5) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 5) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(events.event, '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), not(startsWith(events.event, '$')))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '4_step four'), 0), 1)
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -14577,7 +13709,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -14744,7 +13878,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -14897,7 +14033,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -15062,7 +14200,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -15237,7 +14377,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY persons.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -15431,11 +14573,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_start_and_end.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -15540,44 +14683,11 @@
            WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
      WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/5') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 5), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(5, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 5), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(5, 2)), [filtered_timings[plus(1, intDiv(5, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 5), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(5, 2)), [filtered_uuid[plus(1, intDiv(5, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 5), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(5, 2)), [filtered_timestamp[plus(1, intDiv(5, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 5), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(5, 2)), [filtered_session_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 5), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(5, 2)), [filtered_window_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -15675,11 +14785,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_start_and_end.3
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -15784,44 +14895,11 @@
            WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
      WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/2') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 4), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(4, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 4), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(4, 2)), [filtered_timings[plus(1, intDiv(4, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 4), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(4, 2)), [filtered_uuid[plus(1, intDiv(4, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 4), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(4, 2)), [filtered_timestamp[plus(1, intDiv(4, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 4), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(4, 2)), [filtered_session_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 4), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(4, 2)), [filtered_window_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -15919,11 +14997,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_start_and_end_materialized.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -16012,60 +15091,27 @@
                            (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
                     FROM events
                     LEFT OUTER JOIN
-                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
-                              person_distinct_id_overrides.distinct_id AS distinct_id
-                       FROM person_distinct_id_overrides
-                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                       GROUP BY person_distinct_id_overrides.distinct_id
-                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                 GROUP BY person_id) ARRAY
-              JOIN session_paths AS path_time_tuple,
-                   arrayEnumerate(session_paths) AS session_index) ARRAY
-           JOIN limited_path_timings AS joined_path_tuple,
-                arrayEnumerate(limited_path_timings) AS event_in_session_index
-           WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-     WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
-     GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/5') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 5), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(5, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 5), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(5, 2)), [filtered_timings[plus(1, intDiv(5, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 5), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(5, 2)), [filtered_uuid[plus(1, intDiv(5, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 5), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(5, 2)), [filtered_timestamp[plus(1, intDiv(5, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 5), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(5, 2)), [filtered_session_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 5), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(5, 2)), [filtered_window_id[plus(1, intDiv(5, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(5, 2)), intDiv(5, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(nullIf(nullIf(events.`mat_$current_url`, ''), 'null'), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+                      (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                              person_distinct_id_overrides.distinct_id AS distinct_id
+                       FROM person_distinct_id_overrides
+                       WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                       GROUP BY person_distinct_id_overrides.distinct_id
+                       HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                    WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
+                    ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
+                 GROUP BY person_id) ARRAY
+              JOIN session_paths AS path_time_tuple,
+                   arrayEnumerate(session_paths) AS session_index) ARRAY
+           JOIN limited_path_timings AS joined_path_tuple,
+                arrayEnumerate(limited_path_timings) AS event_in_session_index
+           WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
+     WHERE and(ifNull(equals(last_path_key, '1_/5'), 0), ifNull(equals(path_key, '2_/about'), 0))
+     GROUP BY person_id) AS source
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -16163,11 +15209,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_start_and_end_materialized.3
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -16272,44 +15319,11 @@
            WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
      WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, '/about') AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, indexOf(compact_path, '/2') AS start_target_index, if(ifNull(greater(start_target_index, 0), 0), arraySlice(compact_path, start_target_index), compact_path) AS start_filtered_path, indexOf(start_filtered_path, '/about') AS end_target_index, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_path, end_target_index), start_filtered_path) AS filtered_path, if(ifNull(greater(length(filtered_path), 4), 0), arrayConcat(arraySlice(filtered_path, 1, intDiv(4, 2)), ['...'], arraySlice(filtered_path, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_path) AS limited_path, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timings, start_target_index), timings) AS start_filtered_timings, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timings, end_target_index), start_filtered_timings) AS filtered_timings, if(ifNull(greater(length(filtered_timings), 4), 0), arrayConcat(arraySlice(filtered_timings, 1, intDiv(4, 2)), [filtered_timings[plus(1, intDiv(4, 2))]], arraySlice(filtered_timings, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timings) AS limited_timings, if(ifNull(greater(start_target_index, 0), 0), arraySlice(uuid, start_target_index), uuid) AS start_filtered_uuid, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_uuid, end_target_index), start_filtered_uuid) AS filtered_uuid, if(ifNull(greater(length(filtered_uuid), 4), 0), arrayConcat(arraySlice(filtered_uuid, 1, intDiv(4, 2)), [filtered_uuid[plus(1, intDiv(4, 2))]], arraySlice(filtered_uuid, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_uuid) AS limited_uuid, if(ifNull(greater(start_target_index, 0), 0), arraySlice(timestamp, start_target_index), timestamp) AS start_filtered_timestamp, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_timestamp, end_target_index), start_filtered_timestamp) AS filtered_timestamp, if(ifNull(greater(length(filtered_timestamp), 4), 0), arrayConcat(arraySlice(filtered_timestamp, 1, intDiv(4, 2)), [filtered_timestamp[plus(1, intDiv(4, 2))]], arraySlice(filtered_timestamp, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_timestamp) AS limited_timestamp, if(ifNull(greater(start_target_index, 0), 0), arraySlice(session_id, start_target_index), session_id) AS start_filtered_session_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_session_id, end_target_index), start_filtered_session_id) AS filtered_session_id, if(ifNull(greater(length(filtered_session_id), 4), 0), arrayConcat(arraySlice(filtered_session_id, 1, intDiv(4, 2)), [filtered_session_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_session_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_session_id) AS limited_session_id, if(ifNull(greater(start_target_index, 0), 0), arraySlice(window_id, start_target_index), window_id) AS start_filtered_window_id, if(ifNull(greater(end_target_index, 0), 0), arrayResize(start_filtered_window_id, end_target_index), start_filtered_window_id) AS filtered_window_id, if(ifNull(greater(length(filtered_window_id), 4), 0), arrayConcat(arraySlice(filtered_window_id, 1, intDiv(4, 2)), [filtered_window_id[plus(1, intDiv(4, 2))]], arraySlice(filtered_window_id, multiply(-1, intDiv(4, 2)), intDiv(4, 2))), filtered_window_id) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(nullIf(nullIf(events.`mat_$current_url`, ''), 'null'), ''), '(.)/$', '\\1'), events.event), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2012-05-01 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2021-05-07 23:59:59', 6, 'UTC')))), equals(events.event, '$pageview'))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index
-                                                             WHERE and(ifNull(greater(start_target_index, 0), 0), ifNull(greater(end_target_index, 0), 0))))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_...'), 0), ifNull(equals(path_key, '4_/5'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -16567,11 +15581,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_step_limit.1
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -16667,43 +15682,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 2) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 2) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 2) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 2) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 2) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 2) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -16714,11 +15697,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_step_limit.2
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -16814,43 +15798,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 2) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 2) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 2) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 2) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 2) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 2) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -16943,11 +15895,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_step_limit.4
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -17043,43 +15996,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 3) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 3) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 3) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 3) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 3) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 3) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -17172,11 +16093,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_step_limit.6
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -17272,43 +16194,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 4) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 4) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 4) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 4) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 4) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 4) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '1_/1'), 0), ifNull(equals(path_key, '2_/2'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -17319,11 +16209,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_step_limit.7
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -17419,43 +16310,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 4) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 4) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 4) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 4) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 4) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 4) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '2_/2'), 0), ifNull(equals(path_key, '3_/3'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -17466,11 +16325,12 @@
 # ---
 # name: TestClickhousePathsUDF.test_step_limit.8
   '''
-  SELECT persons.id AS id
+  SELECT source.id AS id
   FROM
     (SELECT person_id AS actor_id,
             groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events,
-            count(*) AS event_count
+            count(*) AS event_count,
+            actor_id AS id
      FROM
        (SELECT person_id AS person_id,
                path AS path,
@@ -17566,43 +16426,11 @@
                 arrayEnumerate(limited_path_timings) AS event_in_session_index))
      WHERE and(ifNull(equals(last_path_key, '3_/3'), 0), ifNull(equals(path_key, '4_/4'), 0))
      GROUP BY person_id) AS source
-  INNER JOIN
-    (SELECT person.id AS id
-     FROM person
-     WHERE and(equals(person.team_id, 99999), in(id,
-                                                   (SELECT source.actor_id AS actor_id
-                                                    FROM
-                                                      (SELECT person_id AS actor_id, groupUniqArray(100)(tuple(timestamp, uuid, session_id, window_id)) AS matching_events, count(*) AS event_count
-                                                       FROM
-                                                         (SELECT person_id AS person_id, path AS path, conversion_time AS conversion_time, event_in_session_index AS event_in_session_index, concat(ifNull(toString(event_in_session_index), ''), '_', ifNull(toString(path), '')) AS path_key, if(ifNull(greater(event_in_session_index, 1), 0), concat(ifNull(toString(minus(event_in_session_index, 1)), ''), '_', ifNull(toString(prev_path), '')), NULL) AS last_path_key, path_dropoff_key AS path_dropoff_key, final_uuid AS uuid, final_timestamp AS timestamp, final_session_id AS session_id, final_window_id AS window_id
-                                                          FROM
-                                                            (SELECT person_id AS person_id, joined_path_tuple.1 AS path, joined_path_tuple.2 AS conversion_time, joined_path_tuple.3 AS prev_path, event_in_session_index, session_index AS session_index, arrayPopFront(arrayPushBack(path_basic, '')) AS path_basic_0, arrayMap((x, y) -> if(ifNull(equals(x, y), isNull(x)
-                                                                                                                                                                                                                                                                                                                                                      and isNull(y)), 0, 1), path_basic, path_basic_0) AS mapping, arrayFilter((x, y) -> y, time, mapping) AS timings, arrayFilter((x, y) -> y, path_basic, mapping) AS compact_path, indexOf(compact_path, NULL) AS target_index, joined_path_tuple.4 AS final_uuid, joined_path_tuple.5 AS final_timestamp, joined_path_tuple.6 AS final_session_id, joined_path_tuple.7 AS final_window_id, arrayFilter((x, y) -> y, uuid_items, mapping) AS uuid, arrayFilter((x, y) -> y, timestamp_items, mapping) AS timestamp, arrayFilter((x, y) -> y, session_id_items, mapping) AS session_id, arrayFilter((x, y) -> y, window_id_items, mapping) AS window_id, if(ifNull(greater(target_index, 0), 0), arraySlice(compact_path, target_index), compact_path) AS filtered_path, arraySlice(filtered_path, 1, 4) AS limited_path, if(ifNull(greater(target_index, 0), 0), arraySlice(timings, target_index), timings) AS filtered_timings, arraySlice(filtered_timings, 1, 4) AS limited_timings, if(ifNull(greater(target_index, 0), 0), arraySlice(uuid, target_index), uuid) AS filtered_uuid, arraySlice(filtered_uuid, 1, 4) AS limited_uuid, if(ifNull(greater(target_index, 0), 0), arraySlice(timestamp, target_index), timestamp) AS filtered_timestamp, arraySlice(filtered_timestamp, 1, 4) AS limited_timestamp, if(ifNull(greater(target_index, 0), 0), arraySlice(session_id, target_index), session_id) AS filtered_session_id, arraySlice(filtered_session_id, 1, 4) AS limited_session_id, if(ifNull(greater(target_index, 0), 0), arraySlice(window_id, target_index), window_id) AS filtered_window_id, arraySlice(filtered_window_id, 1, 4) AS limited_window_id, arrayDifference(limited_timings) AS timings_diff, concat(ifNull(toString(length(limited_path)), ''), '_', ifNull(toString(limited_path[-1]), '')) AS path_dropoff_key, arrayZip(limited_path, timings_diff, arrayPopBack(arrayPushFront(limited_path, '')), limited_uuid, limited_timestamp, limited_session_id, limited_window_id) AS limited_path_timings
-                                                             FROM
-                                                               (SELECT person_id AS person_id, path_time_tuple.1 AS path_basic, path_time_tuple.2 AS time, session_index, arrayZip(path_list, timing_list, arrayDifference(timing_list), uuid_list, timestamp_list, session_id_list, window_id_list) AS paths_tuple, arraySplit(x -> if(ifNull(less(x.3, 1800), 0), 0, 1), paths_tuple) AS session_paths, path_time_tuple.4 AS uuid_items, path_time_tuple.5 AS timestamp_items, path_time_tuple.6 AS session_id_items, path_time_tuple.7 AS window_id_items
-                                                                FROM
-                                                                  (SELECT person_id AS person_id, groupArray(timestamp) AS timing_list, groupArray(path_item) AS path_list, groupArray(uuid) AS uuid_list, groupArray(timestamp) AS timestamp_list, groupArray(session_id) AS session_id_list, groupArray(window_id) AS window_id_list
-                                                                   FROM
-                                                                     (SELECT toTimeZone(events.timestamp, 'UTC') AS timestamp, if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) AS person_id, ifNull(if(equals(events.event, '$screen'), replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$screen_name'), ''), 'null'), '^"|"$', ''), if(equals(events.event, '$pageview'), replaceRegexpAll(ifNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$current_url'), ''), 'null'), '^"|"$', ''), ''), '(.)/$', '\\1'), events.event)), '') AS path_item_ungrouped, events.uuid AS uuid, toTimeZone(events.timestamp, 'UTC') AS timestamp, ifNull(nullIf(nullIf(events.`$session_id`, ''), 'null'), '') AS session_id, ifNull(nullIf(nullIf(events.`$window_id`, ''), 'null'), '') AS window_id, NULL AS groupings, multiMatchAnyIndex(path_item_ungrouped, NULL) AS group_index, (if(ifNull(greater(group_index, 0), 0), groupings[group_index], path_item_ungrouped) AS path_item) AS path_item
-                                                                      FROM events
-                                                                      LEFT OUTER JOIN
-                                                                        (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                         FROM person_distinct_id_overrides
-                                                                         WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                         GROUP BY person_distinct_id_overrides.distinct_id
-                                                                         HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                      WHERE and(equals(events.team_id, 99999), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2011-12-31 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2012-01-07 23:59:59', 6, 'UTC')))))
-                                                                      ORDER BY if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id) ASC, toTimeZone(events.timestamp, 'UTC') ASC)
-                                                                   GROUP BY person_id) ARRAY
-                                                                JOIN session_paths AS path_time_tuple, arrayEnumerate(session_paths) AS session_index) ARRAY
-                                                             JOIN limited_path_timings AS joined_path_tuple, arrayEnumerate(limited_path_timings) AS event_in_session_index))
-                                                       WHERE and(ifNull(equals(last_path_key, '3_/3'), 0), ifNull(equals(path_key, '4_/4'), 0))
-                                                       GROUP BY person_id) AS source)))
-     GROUP BY person.id
-     HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
-  ORDER BY persons.id ASC
+  ORDER BY source.id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/test/__snapshots__/test_retention_query_runner.ambr b/posthog/hogql_queries/insights/test/__snapshots__/test_retention_query_runner.ambr
index d726c177939a3..aaa084cb16b9a 100644
--- a/posthog/hogql_queries/insights/test/__snapshots__/test_retention_query_runner.ambr
+++ b/posthog/hogql_queries/insights/test/__snapshots__/test_retention_query_runner.ambr
@@ -29,7 +29,7 @@
 # ---
 # name: TestClickhouseRetentionGroupAggregation.test_groups_aggregating.1
   '''
-  SELECT groups.key AS key,
+  SELECT source.key AS key,
          source.appearances AS appearances
   FROM
     (SELECT actor_activity.actor_id AS actor_id,
@@ -41,7 +41,8 @@
             arrayExists(x -> ifNull(equals(x, 3), 0), appearance_intervals) AS week_3,
             arrayExists(x -> ifNull(equals(x, 4), 0), appearance_intervals) AS week_4,
             arrayExists(x -> ifNull(equals(x, 5), 0), appearance_intervals) AS week_5,
-            arrayExists(x -> ifNull(equals(x, 6), 0), appearance_intervals) AS week_6
+            arrayExists(x -> ifNull(equals(x, 6), 0), appearance_intervals) AS week_6,
+            actor_activity.actor_id AS key
      FROM
        (SELECT events.`$group_0` AS actor_id,
                arraySort(groupUniqArrayIf(toStartOfWeek(toTimeZone(events.timestamp, 'UTC'), 0), and(equals(events.event, '$pageview'), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfWeek(toDateTime64('2020-06-07 00:00:00.000000', 6, 'UTC'), 0)), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-07-27 00:00:00.000000', 6, 'UTC')))))) AS target_timestamps,
@@ -54,16 +55,11 @@
         GROUP BY actor_id
         HAVING ifNull(equals(breakdown_values, 0), 0)) AS actor_activity
      GROUP BY actor_activity.actor_id) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY length(source.appearances) DESC, source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -130,7 +126,7 @@
 # ---
 # name: TestClickhouseRetentionGroupAggregation.test_groups_aggregating_person_on_events.1
   '''
-  SELECT groups.key AS key,
+  SELECT source.key AS key,
          source.appearances AS appearances
   FROM
     (SELECT actor_activity.actor_id AS actor_id,
@@ -142,7 +138,8 @@
             arrayExists(x -> ifNull(equals(x, 3), 0), appearance_intervals) AS week_3,
             arrayExists(x -> ifNull(equals(x, 4), 0), appearance_intervals) AS week_4,
             arrayExists(x -> ifNull(equals(x, 5), 0), appearance_intervals) AS week_5,
-            arrayExists(x -> ifNull(equals(x, 6), 0), appearance_intervals) AS week_6
+            arrayExists(x -> ifNull(equals(x, 6), 0), appearance_intervals) AS week_6,
+            actor_activity.actor_id AS key
      FROM
        (SELECT events.`$group_0` AS actor_id,
                arraySort(groupUniqArrayIf(toStartOfWeek(toTimeZone(events.timestamp, 'UTC'), 0), and(equals(events.event, '$pageview'), and(greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toStartOfWeek(toDateTime64('2020-06-07 00:00:00.000000', 6, 'UTC'), 0)), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-07-27 00:00:00.000000', 6, 'UTC')))))) AS target_timestamps,
@@ -155,16 +152,11 @@
         GROUP BY actor_id
         HAVING ifNull(equals(breakdown_values, 0), 0)) AS actor_activity
      GROUP BY actor_activity.actor_id) AS source
-  INNER JOIN
-    (SELECT groups.group_type_index AS index,
-            groups.group_key AS key
-     FROM groups
-     WHERE equals(groups.team_id, 99999)
-     GROUP BY groups.group_type_index,
-              groups.group_key) AS groups ON equals(groups.key, source.actor_id)
   ORDER BY length(source.appearances) DESC, source.actor_id ASC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
diff --git a/posthog/hogql_queries/insights/test/test_insight_actors_query_runner.py b/posthog/hogql_queries/insights/test/test_insight_actors_query_runner.py
index 4c5f20ff4d73d..4140066c218ff 100644
--- a/posthog/hogql_queries/insights/test/test_insight_actors_query_runner.py
+++ b/posthog/hogql_queries/insights/test/test_insight_actors_query_runner.py
@@ -99,7 +99,7 @@ def test_insight_persons_lifecycle_query(self):
                 <ActorsQuery select={['properties.name as n']}>
                     <InsightActorsQuery day='2020-01-12' status='returning'>
                         <LifecycleQuery
-                            dateRange={<InsightDateRange date_from={{date_from}} date_to={{date_to}} />}
+                            dateRange={<DateRange date_from={{date_from}} date_to={{date_to}} />}
                             series={[<EventsNode event='$pageview' math='total' />]}
                         />
                     </InsightActorsQuery>
@@ -127,7 +127,7 @@ def test_insight_persons_lifecycle_query_week_monday(self):
                     <InsightActorsQuery day='2020-01-13' status='returning'>
                         <LifecycleQuery
                             interval='week'
-                            dateRange={<InsightDateRange date_from={{date_from}} date_to={{date_to}} />}
+                            dateRange={<DateRange date_from={{date_from}} date_to={{date_to}} />}
                             series={[<EventsNode event='$pageview' math='total' />]}
                         />
                     </InsightActorsQuery>
@@ -155,7 +155,7 @@ def test_insight_persons_lifecycle_query_week_sunday(self):
                     <InsightActorsQuery day='2020-01-12' status='returning'>
                         <LifecycleQuery
                             interval='week'
-                            dateRange={<InsightDateRange date_from={{date_from}} date_to={{date_to}} />}
+                            dateRange={<DateRange date_from={{date_from}} date_to={{date_to}} />}
                             series={[<EventsNode event='$pageview' math='total' />]}
                         />
                     </InsightActorsQuery>
@@ -179,7 +179,7 @@ def test_insight_persons_stickiness_query(self):
                 <ActorsQuery select={['properties.name']}>
                     <InsightActorsQuery day={2}>
                         <StickinessQuery
-                            dateRange={<InsightDateRange date_from='2020-01-09' date_to='2020-01-19' />}
+                            dateRange={<DateRange date_from='2020-01-09' date_to='2020-01-19' />}
                             series={[<EventsNode event='$pageview' />]}
                         />
                     </InsightActorsQuery>
@@ -203,7 +203,7 @@ def test_insight_persons_stickiness_groups_query(self):
                 <ActorsQuery select={['properties.name']}>
                     <InsightActorsQuery day={7}>
                         <StickinessQuery
-                            dateRange={<InsightDateRange date_from='2020-01-01' date_to='2020-01-19' />}
+                            dateRange={<DateRange date_from='2020-01-01' date_to='2020-01-19' />}
                             series={[<EventsNode event='$pageview' math='unique_group' math_group_type_index={0} />]}
                         />
                     </InsightActorsQuery>
@@ -227,7 +227,7 @@ def test_insight_persons_trends_query_with_argmaxV1(self):
                     <ActorsQuery select={['properties.name']}>
                         <InsightActorsQuery day='2020-01-09'>
                             <TrendsQuery
-                                dateRange={<InsightDateRange date_from='2020-01-09' date_to='2020-01-19' />}
+                                dateRange={<DateRange date_from='2020-01-09' date_to='2020-01-19' />}
                                 series={[<EventsNode event='$pageview' />]}
                                 properties={[<PersonPropertyFilter type='person' key='email' value='tom@posthog.com' operator='is_not' />]}
                             />
@@ -255,7 +255,7 @@ def test_insight_persons_trends_query_with_argmaxV2(self):
                     <ActorsQuery select={['properties.name']}>
                         <InsightActorsQuery day='2020-01-09'>
                             <TrendsQuery
-                                dateRange={<InsightDateRange date_from='2020-01-09' date_to='2020-01-19' />}
+                                dateRange={<DateRange date_from='2020-01-09' date_to='2020-01-19' />}
                                 series={[<EventsNode event='$pageview' />]}
                                 properties={[<PersonPropertyFilter type='person' key='email' value='tom@posthog.com' operator='is_not' />]}
                             />
@@ -283,7 +283,7 @@ def test_insight_persons_trends_groups_query(self):
                 <ActorsQuery select={['properties.name']}>
                     <InsightActorsQuery day='2020-01-09'>
                         <TrendsQuery
-                            dateRange={<InsightDateRange date_from='2020-01-01' date_to='2020-01-19' />}
+                            dateRange={<DateRange date_from='2020-01-01' date_to='2020-01-19' />}
                             series={[<EventsNode event='$pageview' math='unique_group' math_group_type_index={0} />]}
                         />
                     </InsightActorsQuery>
@@ -306,7 +306,7 @@ def test_insight_persons_funnels_query(self):
                     <ActorsQuery select={['properties.name']}>
                         <FunnelsActorsQuery funnelStep={2}>
                             <FunnelsQuery
-                                dateRange={<InsightDateRange date_from='2020-01-01' date_to='2020-01-19' />}
+                                dateRange={<DateRange date_from='2020-01-01' date_to='2020-01-19' />}
                                 series={[<EventsNode event='$pageview' />, <EventsNode event='$pageview' />]}
                             />
                         </FunnelsActorsQuery>
@@ -330,7 +330,7 @@ def test_insight_groups_funnels_query(self):
                         <FunnelsActorsQuery funnelStep={2}>
                             <FunnelsQuery
                                 aggregation_group_type_index={0}
-                                dateRange={<InsightDateRange date_from='2020-01-01' date_to='2020-01-19' />}
+                                dateRange={<DateRange date_from='2020-01-01' date_to='2020-01-19' />}
                                 series={[<EventsNode event='$pageview' />, <EventsNode event='$pageview' />]}
                             />
                         </FunnelsActorsQuery>
diff --git a/posthog/hogql_queries/insights/test/test_lifecycle_query_runner.py b/posthog/hogql_queries/insights/test/test_lifecycle_query_runner.py
index 258f4bed96859..204deb37db23b 100644
--- a/posthog/hogql_queries/insights/test/test_lifecycle_query_runner.py
+++ b/posthog/hogql_queries/insights/test/test_lifecycle_query_runner.py
@@ -5,7 +5,7 @@
 from posthog.models.team import WeekStartDay
 from posthog.models.utils import UUIDT
 from posthog.schema import (
-    InsightDateRange,
+    DateRange,
     IntervalType,
     LifecycleQuery,
     EventsNode,
@@ -61,7 +61,7 @@ def _create_events(self, data, event="$pageview"):
     def _create_query_runner(self, date_from, date_to, interval, aggregation_group_type_index) -> LifecycleQueryRunner:
         series = [EventsNode(event="$pageview")]
         query = LifecycleQuery(
-            dateRange=InsightDateRange(date_from=date_from, date_to=date_to),
+            dateRange=DateRange(date_from=date_from, date_to=date_to),
             interval=interval,
             series=series,
             aggregation_group_type_index=aggregation_group_type_index,
@@ -641,7 +641,7 @@ def _create_test_events(self):
     def _create_query_runner(self, date_from, date_to, interval) -> LifecycleQueryRunner:
         series = [EventsNode(event="$pageview")]
         query = LifecycleQuery(
-            dateRange=InsightDateRange(date_from=date_from, date_to=date_to),
+            dateRange=DateRange(date_from=date_from, date_to=date_to),
             interval=interval,
             series=series,
         )
@@ -958,7 +958,7 @@ def test_lifecycle_trend(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1008,7 +1008,7 @@ def test_lifecycle_trend_all_events(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event=None)],
                 ),
@@ -1072,7 +1072,7 @@ def test_lifecycle_trend_with_zero_person_ids(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1173,7 +1173,7 @@ def test_lifecycle_trend_prop_filtering(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event="$pageview")],
                     properties=[EventPropertyFilter(key="$number", value="1", operator=PropertyOperator.EXACT)],
@@ -1198,7 +1198,7 @@ def test_lifecycle_trend_prop_filtering(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[
                         EventsNode(
@@ -1304,7 +1304,7 @@ def test_lifecycle_trend_person_prop_filtering(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[
                         EventsNode(
@@ -1373,7 +1373,7 @@ def test_lifecycle_trends_distinct_id_repeat(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1418,7 +1418,7 @@ def test_lifecycle_trend_action(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[ActionsNode(id=pageview_action.pk)],
                 ),
@@ -1462,7 +1462,7 @@ def test_lifecycle_trend_all_time(self):
                 LifecycleQueryRunner(
                     team=self.team,
                     query=LifecycleQuery(
-                        dateRange=InsightDateRange(date_from="all"),
+                        dateRange=DateRange(date_from="all"),
                         interval=IntervalType.DAY,
                         series=[EventsNode(event="$pageview")],
                     ),
@@ -1509,7 +1509,7 @@ def test_lifecycle_trend_weeks_sunday(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-02-05T00:00:00Z", date_to="2020-03-09T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-02-05T00:00:00Z", date_to="2020-03-09T00:00:00Z"),
                     interval=IntervalType.WEEK,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1568,7 +1568,7 @@ def test_lifecycle_trend_weeks_monday(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-02-05T00:00:00Z", date_to="2020-03-09T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-02-05T00:00:00Z", date_to="2020-03-09T00:00:00Z"),
                     interval=IntervalType.WEEK,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1623,7 +1623,7 @@ def test_lifecycle_trend_months(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-02-01T00:00:00Z", date_to="2020-09-01T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-02-01T00:00:00Z", date_to="2020-09-01T00:00:00Z"),
                     interval=IntervalType.MONTH,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1666,7 +1666,7 @@ def test_filter_test_accounts(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                    dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event="$pageview")],
                     filterTestAccounts=True,
@@ -1711,7 +1711,7 @@ def test_timezones(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12", date_to="2020-01-19"),
+                    dateRange=DateRange(date_from="2020-01-12", date_to="2020-01-19"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1737,7 +1737,7 @@ def test_timezones(self):
             LifecycleQueryRunner(
                 team=self.team,
                 query=LifecycleQuery(
-                    dateRange=InsightDateRange(date_from="2020-01-12", date_to="2020-01-19"),
+                    dateRange=DateRange(date_from="2020-01-12", date_to="2020-01-19"),
                     interval=IntervalType.DAY,
                     series=[EventsNode(event="$pageview")],
                 ),
@@ -1784,7 +1784,7 @@ def test_sampling(self):
         LifecycleQueryRunner(
             team=self.team,
             query=LifecycleQuery(
-                dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                 interval=IntervalType.DAY,
                 series=[EventsNode(event="$pageview")],
                 samplingFactor=0.1,
@@ -1831,7 +1831,7 @@ def test_cohort_filter(self):
         response = LifecycleQueryRunner(
             team=self.team,
             query=LifecycleQuery(
-                dateRange=InsightDateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
+                dateRange=DateRange(date_from="2020-01-12T00:00:00Z", date_to="2020-01-19T00:00:00Z"),
                 interval=IntervalType.DAY,
                 series=[EventsNode(event="$pageview")],
                 properties=[CohortPropertyFilter(value=cohort.pk)],
diff --git a/posthog/hogql_queries/insights/test/test_stickiness_query_runner.py b/posthog/hogql_queries/insights/test/test_stickiness_query_runner.py
index 394fdcf0142b3..bc4754d04e9b3 100644
--- a/posthog/hogql_queries/insights/test/test_stickiness_query_runner.py
+++ b/posthog/hogql_queries/insights/test/test_stickiness_query_runner.py
@@ -14,7 +14,7 @@
 from posthog.schema import (
     ActionsNode,
     CohortPropertyFilter,
-    InsightDateRange,
+    DateRange,
     ElementPropertyFilter,
     EmptyPropertyFilter,
     EventPropertyFilter,
@@ -215,7 +215,7 @@ def _run_query(
 
         query = StickinessQuery(
             series=query_series,
-            dateRange=InsightDateRange(date_from=query_date_from, date_to=query_date_to),
+            dateRange=DateRange(date_from=query_date_from, date_to=query_date_to),
             interval=query_interval,
             properties=properties,
             stickinessFilter=filters,
diff --git a/posthog/hogql_queries/insights/trends/aggregation_operations.py b/posthog/hogql_queries/insights/trends/aggregation_operations.py
index 84e7c181f7c13..9e88bfca8b4aa 100644
--- a/posthog/hogql_queries/insights/trends/aggregation_operations.py
+++ b/posthog/hogql_queries/insights/trends/aggregation_operations.py
@@ -92,6 +92,7 @@ def requires_query_orchestration(self) -> bool:
             "weekly_active",
             "monthly_active",
             "first_time_for_user",
+            "first_matching_event_for_user",
         ]
 
         return self.is_count_per_actor_variant() or self.series.math in math_to_return_true
@@ -116,6 +117,9 @@ def is_active_users_math(self):
     def is_first_time_ever_math(self):
         return self.series.math == "first_time_for_user"
 
+    def is_first_matching_event(self):
+        return self.series.math == "first_matching_event_for_user"
+
     def _math_func(self, method: str, override_chain: Optional[list[str | int]]) -> ast.Call:
         if override_chain is not None:
             return ast.Call(name=method, args=[ast.Field(chain=override_chain)])
@@ -452,7 +456,11 @@ def _first_time_parent_query(self, inner_query: ast.SelectQuery):
         return query
 
     def get_first_time_math_query_orchestrator(
-        self, events_where_clause: ast.Expr, sample_value: ast.RatioExpr, event_name_filter: ast.Expr | None = None
+        self,
+        events_where_clause: ast.Expr,
+        sample_value: ast.RatioExpr,
+        event_name_filter: ast.Expr | None = None,
+        is_first_matching_event: bool = False,
     ):
         date_placeholders = self.query_date_range.to_placeholders()
         date_from = parse_expr(
@@ -479,6 +487,7 @@ def __init__(self):
                     filters=events_where_clause,
                     event_or_action_filter=event_name_filter,
                     ratio=sample_value,
+                    is_first_matching_event=is_first_matching_event,
                 )
                 self.parent_query_builder = QueryAlternator(parent_select)
 
diff --git a/posthog/hogql_queries/insights/trends/test/__snapshots__/test_trends.ambr b/posthog/hogql_queries/insights/trends/test/__snapshots__/test_trends.ambr
index 4b096b060262e..729923069bad6 100644
--- a/posthog/hogql_queries/insights/trends/test/__snapshots__/test_trends.ambr
+++ b/posthog/hogql_queries/insights/trends/test/__snapshots__/test_trends.ambr
@@ -42,11 +42,14 @@
 # name: TestTrends.test_action_filtering_with_cohort.4
   '''
   /* celery:posthog.tasks.calculate_cohort.clear_stale_cohort */
-  SELECT count()
+  SELECT team_id,
+         count() AS stale_people_count
   FROM cohortpeople
-  WHERE team_id = 99999
+  WHERE team_id IN [1, 2, 3, 4, 5 /* ... */]
     AND cohort_id = 99999
     AND version < 2
+  GROUP BY team_id
+  HAVING stale_people_count > 0
   '''
 # ---
 # name: TestTrends.test_action_filtering_with_cohort.5
@@ -138,11 +141,14 @@
 # name: TestTrends.test_action_filtering_with_cohort_poe_v2.4
   '''
   /* celery:posthog.tasks.calculate_cohort.clear_stale_cohort */
-  SELECT count()
+  SELECT team_id,
+         count() AS stale_people_count
   FROM cohortpeople
-  WHERE team_id = 99999
+  WHERE team_id IN [1, 2, 3, 4, 5 /* ... */]
     AND cohort_id = 99999
     AND version < 2
+  GROUP BY team_id
+  HAVING stale_people_count > 0
   '''
 # ---
 # name: TestTrends.test_action_filtering_with_cohort_poe_v2.5
@@ -278,7 +284,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY source.event_count DESC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -839,26 +847,96 @@
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                      and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start,
+               breakdown_value AS breakdown_value
+        FROM
+          (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start,
+                  ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value
+           FROM events AS e SAMPLE 1.0
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+           GROUP BY day_start,
+                    breakdown_value)
+        GROUP BY day_start,
+                 breakdown_value
+        ORDER BY day_start ASC, breakdown_value ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE isNotNull(breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.1
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                      and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start,
+               breakdown_value AS breakdown_value
+        FROM
+          (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start,
+                  ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value
+           FROM events AS e SAMPLE 1.0
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+           GROUP BY day_start,
+                    breakdown_value)
+        GROUP BY day_start,
+                 breakdown_value
+        ORDER BY day_start ASC, breakdown_value ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE isNotNull(breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.10
@@ -1074,6 +1152,147 @@
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.2
+  '''
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      arrayMap(i -> if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', i), breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                      and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start,
+               [ifNull(toString(breakdown_value_1), '$$_posthog_breakdown_null_$$')] AS breakdown_value
+        FROM
+          (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start,
+                  ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value_1
+           FROM events AS e SAMPLE 1.0
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+           GROUP BY day_start,
+                    breakdown_value_1)
+        GROUP BY day_start,
+                 breakdown_value_1
+        ORDER BY day_start ASC, breakdown_value ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(has(breakdown_value, '$$_posthog_breakdown_other_$$'), 2, if(has(breakdown_value, '$$_posthog_breakdown_null_$$'), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE arrayExists(x -> isNotNull(x), breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(has(breakdown_value, '$$_posthog_breakdown_other_$$'), 2, if(has(breakdown_value, '$$_posthog_breakdown_null_$$'), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
+  '''
+# ---
+# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.3
+  '''
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      arrayMap(i -> if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', i), breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                      and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start,
+               [ifNull(toString(breakdown_value_1), '$$_posthog_breakdown_null_$$')] AS breakdown_value
+        FROM
+          (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start,
+                  ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value_1
+           FROM events AS e SAMPLE 1.0
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+           GROUP BY day_start,
+                    breakdown_value_1)
+        GROUP BY day_start,
+                 breakdown_value_1
+        ORDER BY day_start ASC, breakdown_value ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(has(breakdown_value, '$$_posthog_breakdown_other_$$'), 2, if(has(breakdown_value, '$$_posthog_breakdown_null_$$'), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE arrayExists(x -> isNotNull(x), breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(has(breakdown_value, '$$_posthog_breakdown_other_$$'), 2, if(has(breakdown_value, '$$_posthog_breakdown_null_$$'), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
+  '''
+# ---
+# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.4
+  '''
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      arrayMap(i -> if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', i), breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                      and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start,
+               [ifNull(toString(breakdown_value_1), '$$_posthog_breakdown_null_$$')] AS breakdown_value
+        FROM
+          (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start,
+                  ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value_1
+           FROM events AS e SAMPLE 1.0
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+           GROUP BY day_start,
+                    breakdown_value_1)
+        GROUP BY day_start,
+                 breakdown_value_1
+        ORDER BY day_start ASC, breakdown_value ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(has(breakdown_value, '$$_posthog_breakdown_other_$$'), 2, if(has(breakdown_value, '$$_posthog_breakdown_null_$$'), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE arrayExists(x -> isNotNull(x), breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(has(breakdown_value, '$$_posthog_breakdown_other_$$'), 2, if(has(breakdown_value, '$$_posthog_breakdown_null_$$'), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
+  '''
+# ---
+# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.5
   '''
   /* celery:posthog.tasks.tasks.sync_insight_caching_state */
   SELECT team_id,
@@ -1085,7 +1304,7 @@
   ORDER BY age;
   '''
 # ---
-# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.3
+# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.6
   '''
   /* celery:posthog.tasks.tasks.sync_insight_caching_state */
   SELECT team_id,
@@ -1097,7 +1316,7 @@
   ORDER BY age;
   '''
 # ---
-# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.4
+# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.7
   '''
   /* celery:posthog.tasks.tasks.sync_insight_caching_state */
   SELECT team_id,
@@ -1109,43 +1328,7 @@
   ORDER BY age;
   '''
 # ---
-# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.5
-  '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.6
-  '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.7
-  '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.8
+# name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.8
   '''
   /* celery:posthog.tasks.tasks.sync_insight_caching_state */
   SELECT team_id,
@@ -1422,7 +1605,9 @@
      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)) SETTINGS optimize_aggregation_in_order=1) AS persons ON equals(persons.id, source.actor_id)
   ORDER BY source.event_count DESC
   LIMIT 101
-  OFFSET 0 SETTINGS readonly=2,
+  OFFSET 0 SETTINGS optimize_aggregation_in_order=1,
+                    join_algorithm='auto',
+                    readonly=2,
                     max_execution_time=60,
                     allow_experimental_object_type=1,
                     format_csv_allow_double_quotes=0,
@@ -1781,18 +1966,6 @@
 # ---
 # name: TestTrends.test_person_filtering_in_cohort_in_action
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action.1
-  '''
   
   SELECT count(DISTINCT person_id)
   FROM cohortpeople
@@ -1801,7 +1974,7 @@
     AND version = NULL
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action.2
+# name: TestTrends.test_person_filtering_in_cohort_in_action.1
   '''
   /* cohort_calculation: */
   SELECT count(DISTINCT person_id)
@@ -1811,7 +1984,7 @@
     AND version = 0
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action.3
+# name: TestTrends.test_person_filtering_in_cohort_in_action.2
   '''
   SELECT groupArray(1)(date)[1] AS date,
                       arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
@@ -1861,19 +2034,57 @@
                        max_bytes_before_external_group_by=0
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2
+# name: TestTrends.test_person_filtering_in_cohort_in_action.3
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                      and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start,
+               breakdown_value AS breakdown_value
+        FROM
+          (SELECT count() AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start,
+                  ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value
+           FROM events AS e SAMPLE 1
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), and(equals(e.event, 'sign up'), ifNull(in(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id),
+                                                                                                                                                                                                                                                                                                                                                                          (SELECT cohortpeople.person_id AS person_id
+                                                                                                                                                                                                                                                                                                                                                                           FROM cohortpeople
+                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))), 0)))
+           GROUP BY day_start,
+                    breakdown_value)
+        GROUP BY day_start,
+                 breakdown_value
+        ORDER BY day_start ASC, breakdown_value ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE isNotNull(breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.1
+# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2
   '''
   
   SELECT count(DISTINCT person_id)
@@ -1883,7 +2094,7 @@
     AND version = NULL
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.2
+# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.1
   '''
   /* cohort_calculation: */
   SELECT count(DISTINCT person_id)
@@ -1893,6 +2104,56 @@
     AND version = 0
   '''
 # ---
+# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.2
+  '''
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                      and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start,
+               breakdown_value AS breakdown_value
+        FROM
+          (SELECT count() AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start,
+                  ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value
+           FROM events AS e SAMPLE 1
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), and(equals(e.event, 'sign up'), ifNull(in(if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id),
+                                                                                                                                                                                                                                                                                                                                                                          (SELECT cohortpeople.person_id AS person_id
+                                                                                                                                                                                                                                                                                                                                                                           FROM cohortpeople
+                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))), 0)))
+           GROUP BY day_start,
+                    breakdown_value)
+        GROUP BY day_start,
+                 breakdown_value
+        ORDER BY day_start ASC, breakdown_value ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE isNotNull(breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
+  '''
+# ---
 # name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.3
   '''
   SELECT groupArray(1)(date)[1] AS date,
@@ -3649,14 +3910,28 @@
 # ---
 # name: TestTrends.test_trends_any_event_total_count
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+         arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                   and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total
+  FROM
+    (SELECT sum(total) AS count,
+            day_start AS day_start
+     FROM
+       (SELECT count() AS total,
+               toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start
+        FROM events AS e SAMPLE 1
+        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))
+        GROUP BY day_start)
+     GROUP BY day_start
+     ORDER BY day_start ASC)
+  ORDER BY arraySum(total) DESC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_trends_any_event_total_count.1
@@ -3671,7 +3946,7 @@
        (SELECT count() AS total,
                toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start
         FROM events AS e SAMPLE 1
-        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))
+        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
         GROUP BY day_start)
      GROUP BY day_start
      ORDER BY day_start ASC)
@@ -3713,14 +3988,55 @@
 # ---
 # name: TestTrends.test_trends_breakdown_cumulative
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayFill(x -> ifNull(greater(x, 0), 0), arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                                                               and isNull(_match_date)), _days_for_count), _index), 1))), date)) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT day_start AS day_start,
+               sum(count) OVER (PARTITION BY breakdown_value
+                                ORDER BY day_start ASC) AS count,
+                               breakdown_value AS breakdown_value
+        FROM
+          (SELECT sum(total) AS count,
+                  day_start AS day_start,
+                  breakdown_value AS breakdown_value
+           FROM
+             (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                     min(toStartOfDay(toTimeZone(e.timestamp, 'UTC'))) AS day_start,
+                     ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value
+              FROM events AS e SAMPLE 1
+              LEFT OUTER JOIN
+                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                        person_distinct_id_overrides.distinct_id AS distinct_id
+                 FROM person_distinct_id_overrides
+                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                 GROUP BY person_distinct_id_overrides.distinct_id
+                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+              WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+              GROUP BY if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id),
+                       breakdown_value)
+           GROUP BY day_start,
+                    breakdown_value
+           ORDER BY day_start ASC, breakdown_value ASC)
+        ORDER BY day_start ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE isNotNull(breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_trends_breakdown_cumulative.1
@@ -3778,14 +4094,55 @@
 # ---
 # name: TestTrends.test_trends_breakdown_cumulative_poe_v2
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT groupArray(1)(date)[1] AS date,
+                      arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
+                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+  FROM
+    (SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+            arrayFill(x -> ifNull(greater(x, 0), 0), arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                                                               and isNull(_match_date)), _days_for_count), _index), 1))), date)) AS total,
+            breakdown_value AS breakdown_value,
+            rowNumberInAllBlocks() AS row_number
+     FROM
+       (SELECT day_start AS day_start,
+               sum(count) OVER (PARTITION BY breakdown_value
+                                ORDER BY day_start ASC) AS count,
+                               breakdown_value AS breakdown_value
+        FROM
+          (SELECT sum(total) AS count,
+                  day_start AS day_start,
+                  breakdown_value AS breakdown_value
+           FROM
+             (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                     min(toStartOfDay(toTimeZone(e.timestamp, 'UTC'))) AS day_start,
+                     ifNull(nullIf(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(e.properties, '$some_property'), ''), 'null'), '^"|"$', '')), ''), '$$_posthog_breakdown_null_$$') AS breakdown_value
+              FROM events AS e SAMPLE 1
+              LEFT OUTER JOIN
+                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                        person_distinct_id_overrides.distinct_id AS distinct_id
+                 FROM person_distinct_id_overrides
+                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                 GROUP BY person_distinct_id_overrides.distinct_id
+                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+              WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+              GROUP BY if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id),
+                       breakdown_value)
+           GROUP BY day_start,
+                    breakdown_value
+           ORDER BY day_start ASC, breakdown_value ASC)
+        ORDER BY day_start ASC)
+     GROUP BY breakdown_value
+     ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC)
+  WHERE isNotNull(breakdown_value)
+  GROUP BY breakdown_value
+  ORDER BY if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_other_$$'), 0), 2, if(ifNull(equals(breakdown_value, '$$_posthog_breakdown_null_$$'), 0), 1, 0)) ASC, arraySum(total) DESC, breakdown_value ASC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_trends_breakdown_cumulative_poe_v2.1
@@ -4082,19 +4439,33 @@
 # ---
 # name: TestTrends.test_trends_compare_day_interval_relative_range
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+         arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                   and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total
+  FROM
+    (SELECT sum(total) AS count,
+            day_start AS day_start
+     FROM
+       (SELECT count() AS total,
+               toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start
+        FROM events AS e SAMPLE 1
+        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+        GROUP BY day_start)
+     GROUP BY day_start
+     ORDER BY day_start ASC)
+  ORDER BY arraySum(total) DESC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_trends_compare_day_interval_relative_range.1
   '''
-  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-21 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-21 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 23:59:59', 6, 'UTC'))))), 1))) AS date,
          arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
                                                                                                                                                                                                    and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total
   FROM
@@ -4104,7 +4475,7 @@
        (SELECT count() AS total,
                toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start
         FROM events AS e SAMPLE 1
-        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-21 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
         GROUP BY day_start)
      GROUP BY day_start
      ORDER BY day_start ASC)
@@ -4120,7 +4491,7 @@
 # ---
 # name: TestTrends.test_trends_compare_day_interval_relative_range.2
   '''
-  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-21 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-21 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 23:59:59', 6, 'UTC'))))), 1))) AS date,
+  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
          arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
                                                                                                                                                                                                    and isNull(_match_date)), _days_for_count), _index), 1))), date) AS total
   FROM
@@ -4130,7 +4501,7 @@
        (SELECT count() AS total,
                toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start
         FROM events AS e SAMPLE 1
-        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-21 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+        WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
         GROUP BY day_start)
      GROUP BY day_start
      ORDER BY day_start ASC)
@@ -4412,14 +4783,33 @@
 # ---
 # name: TestTrends.test_trends_per_day_cumulative
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+         arrayFill(x -> ifNull(greater(x, 0), 0), arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                                                            and isNull(_match_date)), _days_for_count), _index), 1))), date)) AS total
+  FROM
+    (SELECT day_start AS day_start,
+            sum(count) OVER (
+                             ORDER BY day_start ASC) AS count
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start
+        FROM
+          (SELECT count() AS total,
+                  toStartOfDay(toTimeZone(e.timestamp, 'UTC')) AS day_start
+           FROM events AS e SAMPLE 1
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+           GROUP BY day_start)
+        GROUP BY day_start
+        ORDER BY day_start ASC)
+     ORDER BY day_start ASC)
+  ORDER BY arraySum(total) DESC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_trends_per_day_cumulative.1
@@ -4455,14 +4845,40 @@
 # ---
 # name: TestTrends.test_trends_per_day_dau_cumulative
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  SELECT arrayMap(number -> plus(toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC'))), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))))), 1))) AS date,
+         arrayFill(x -> ifNull(greater(x, 0), 0), arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
+                                                                                                                                                                                                                                            and isNull(_match_date)), _days_for_count), _index), 1))), date)) AS total
+  FROM
+    (SELECT day_start AS day_start,
+            sum(count) OVER (
+                             ORDER BY day_start ASC) AS count
+     FROM
+       (SELECT sum(total) AS count,
+               day_start AS day_start
+        FROM
+          (SELECT count(DISTINCT if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id)) AS total,
+                  min(toStartOfDay(toTimeZone(e.timestamp, 'UTC'))) AS day_start
+           FROM events AS e SAMPLE 1
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS e__override ON equals(e.distinct_id, e__override.distinct_id)
+           WHERE and(equals(e.team_id, 99999), greaterOrEquals(toTimeZone(e.timestamp, 'UTC'), toStartOfDay(assumeNotNull(parseDateTime64BestEffortOrNull('2019-12-28 00:00:00', 6, 'UTC')))), lessOrEquals(toTimeZone(e.timestamp, 'UTC'), assumeNotNull(parseDateTime64BestEffortOrNull('2020-01-04 23:59:59', 6, 'UTC'))), equals(e.event, 'sign up'))
+           GROUP BY if(not(empty(e__override.distinct_id)), e__override.person_id, e.person_id))
+        GROUP BY day_start
+        ORDER BY day_start ASC)
+     ORDER BY day_start ASC)
+  ORDER BY arraySum(total) DESC
+  LIMIT 50000 SETTINGS readonly=2,
+                       max_execution_time=60,
+                       allow_experimental_object_type=1,
+                       format_csv_allow_double_quotes=0,
+                       max_ast_elements=4000000,
+                       max_expanded_ast_elements=4000000,
+                       max_bytes_before_external_group_by=0
   '''
 # ---
 # name: TestTrends.test_trends_per_day_dau_cumulative.1
diff --git a/posthog/hogql_queries/insights/trends/test/test_trends.py b/posthog/hogql_queries/insights/trends/test/test_trends.py
index 5fe2bc58cc261..04d4fc97fd312 100644
--- a/posthog/hogql_queries/insights/trends/test/test_trends.py
+++ b/posthog/hogql_queries/insights/trends/test/test_trends.py
@@ -48,7 +48,7 @@
     BreakdownFilter,
     DataWarehouseNode,
     EventsNode,
-    InsightDateRange,
+    DateRange,
     PropertyGroupFilter,
     TrendsFilter,
     TrendsQuery,
@@ -178,7 +178,7 @@ def convert_filter_to_trends_query(filter: Filter) -> TrendsQuery:
         series=series,
         kind="TrendsQuery",
         filterTestAccounts=filter.filter_test_accounts,
-        dateRange=InsightDateRange(date_from=filter_as_dict.get("date_from"), date_to=filter_as_dict.get("date_to")),
+        dateRange=DateRange(date_from=filter_as_dict.get("date_from"), date_to=filter_as_dict.get("date_to")),
         samplingFactor=filter.sampling_factor,
         aggregation_group_type_index=filter.aggregation_group_type_index,
         breakdownFilter=BreakdownFilter(
diff --git a/posthog/hogql_queries/insights/trends/test/test_trends_actors_query_builder.py b/posthog/hogql_queries/insights/trends/test/test_trends_actors_query_builder.py
index 4d3c66acae670..69e6642d54cc2 100644
--- a/posthog/hogql_queries/insights/trends/test/test_trends_actors_query_builder.py
+++ b/posthog/hogql_queries/insights/trends/test/test_trends_actors_query_builder.py
@@ -17,14 +17,14 @@
     Compare,
     CompareFilter,
     EventsNode,
-    InsightDateRange,
+    DateRange,
     IntervalType,
     TrendsFilter,
     TrendsQuery,
 )
 from posthog.test.base import BaseTest
 
-default_query = TrendsQuery(series=[EventsNode(event="$pageview")], dateRange=InsightDateRange(date_from="-7d"))
+default_query = TrendsQuery(series=[EventsNode(event="$pageview")], dateRange=DateRange(date_from="-7d"))
 
 
 class TestTrendsActorsQueryBuilder(BaseTest):
@@ -339,9 +339,7 @@ def test_date_range_explicit_date_from(self):
         self.team.timezone = "Europe/Berlin"
 
         trends_query = default_query.model_copy(
-            update={
-                "dateRange": InsightDateRange(date_from="2024-05-08T14:29:13.634000Z", date_to=None, explicitDate=True)
-            },
+            update={"dateRange": DateRange(date_from="2024-05-08T14:29:13.634000Z", date_to=None, explicitDate=True)},
             deep=True,
         )
         with freeze_time("2024-05-08T15:32:00.000Z"):
@@ -353,7 +351,7 @@ def test_date_range_explicit_date_from(self):
     def test_date_range_explicit_date_to(self):
         trends_query = default_query.model_copy(
             update={
-                "dateRange": InsightDateRange(
+                "dateRange": DateRange(
                     date_from="2024-05-08T14:29:13.634000Z", date_to="2024-05-08T14:32:57.692000Z", explicitDate=True
                 )
             },
@@ -370,7 +368,7 @@ def test_date_range_explicit_monthly_active_users_math(self):
         trends_query = default_query.model_copy(
             update={
                 "series": [EventsNode(event="$pageview", math=BaseMathType.MONTHLY_ACTIVE)],
-                "dateRange": InsightDateRange(
+                "dateRange": DateRange(
                     date_from="2024-05-08T14:29:13.634000Z", date_to="2024-05-08T14:32:57.692000Z", explicitDate=True
                 ),
             },
diff --git a/posthog/hogql_queries/insights/trends/test/test_trends_dashboard_filters.py b/posthog/hogql_queries/insights/trends/test/test_trends_dashboard_filters.py
index e3513b4654abc..9ffecbd9baf5d 100644
--- a/posthog/hogql_queries/insights/trends/test/test_trends_dashboard_filters.py
+++ b/posthog/hogql_queries/insights/trends/test/test_trends_dashboard_filters.py
@@ -6,7 +6,7 @@
     ActionsNode,
     BreakdownFilter,
     DashboardFilter,
-    InsightDateRange,
+    DateRange,
     EventPropertyFilter,
     EventsNode,
     FilterLogicalOperator,
@@ -40,7 +40,7 @@ def _create_query_runner(
     ) -> TrendsQueryRunner:
         query_series: list[EventsNode | ActionsNode] = [EventsNode(event="$pageview")] if series is None else series
         query = TrendsQuery(
-            dateRange=InsightDateRange(date_from=date_from, date_to=date_to, explicitDate=explicit_date),
+            dateRange=DateRange(date_from=date_from, date_to=date_to, explicitDate=explicit_date),
             interval=interval,
             series=query_series,
             trendsFilter=trends_filters,
diff --git a/posthog/hogql_queries/insights/trends/test/test_trends_data_warehouse_query.py b/posthog/hogql_queries/insights/trends/test/test_trends_data_warehouse_query.py
index 63b4c8e276993..6f8f52af5f2e5 100644
--- a/posthog/hogql_queries/insights/trends/test/test_trends_data_warehouse_query.py
+++ b/posthog/hogql_queries/insights/trends/test/test_trends_data_warehouse_query.py
@@ -11,7 +11,7 @@
     BreakdownFilter,
     BreakdownType,
     ChartDisplayType,
-    InsightDateRange,
+    DateRange,
     DataWarehouseNode,
     DataWarehouseEventsModifier,
     TrendsQuery,
@@ -160,7 +160,7 @@ def test_trends_data_warehouse(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
@@ -185,7 +185,7 @@ def test_trends_entity_property(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
@@ -211,7 +211,7 @@ def test_trends_query_properties(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
@@ -237,7 +237,7 @@ def test_trends_breakdown(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
@@ -311,7 +311,7 @@ def test_trends_breakdown_with_event_property(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
@@ -368,7 +368,7 @@ def test_trends_breakdown_on_view(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id="saved_view",
@@ -391,7 +391,7 @@ def test_trends_breakdown_with_property(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
@@ -420,7 +420,7 @@ def assert_column_names_with_display_type(self, display_type: ChartDisplayType):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
@@ -463,7 +463,7 @@ def test_trends_with_multiple_property_types(self):
 
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[
                 DataWarehouseNode(
                     id=table_name,
diff --git a/posthog/hogql_queries/insights/trends/test/test_trends_persons.py b/posthog/hogql_queries/insights/trends/test/test_trends_persons.py
index 6ef3306715682..aa78ee5b579f4 100644
--- a/posthog/hogql_queries/insights/trends/test/test_trends_persons.py
+++ b/posthog/hogql_queries/insights/trends/test/test_trends_persons.py
@@ -28,7 +28,7 @@
     EventsNode,
     HogQLQueryModifiers,
     InsightActorsQuery,
-    InsightDateRange,
+    DateRange,
     IntervalType,
     MathGroupTypeIndex,
     MultipleBreakdownType,
@@ -306,7 +306,7 @@ def test_trends_single_series_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-29")
@@ -320,7 +320,7 @@ def test_trends_multiple_series_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview"), EventsNode(event="$pageleave")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-29")
@@ -341,7 +341,7 @@ def test_trends_event_breakdown_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="$browser"),
         )
 
@@ -361,7 +361,7 @@ def test_trends_person_breakdown_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="$geoip_country_code", breakdown_type=BreakdownType.PERSON),
         )
 
@@ -382,7 +382,7 @@ def test_trends_breakdown_others_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="$browser", breakdown_limit=1),
         )
 
@@ -405,7 +405,7 @@ def test_trends_multiple_breakdowns_others_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="$browser")],
                 breakdown_limit=1,
@@ -431,7 +431,7 @@ def test_trends_filter_by_other(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="some_property", type=MultipleBreakdownType.EVENT)],
                 breakdown_limit=1,
@@ -443,7 +443,7 @@ def test_trends_filter_by_other(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[
                     Breakdown(property="some_property", type=MultipleBreakdownType.EVENT),
@@ -464,7 +464,7 @@ def test_trends_breakdown_null_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="$browser", breakdown_limit=1),
         )
 
@@ -482,7 +482,7 @@ def test_trends_breakdown_hogql_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="properties.some_property", breakdown_type=BreakdownType.HOGQL),
         )
 
@@ -504,7 +504,7 @@ def test_trends_cohort_breakdown_persons(self):
         )
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown=[cohort.pk], breakdown_type=BreakdownType.COHORT),
         )
 
@@ -530,7 +530,7 @@ def test_trends_multi_cohort_breakdown_persons(self):
         )
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown=[cohort1.pk, cohort2.pk], breakdown_type=BreakdownType.COHORT),
         )
 
@@ -557,7 +557,7 @@ def trends_all_cohort_breakdown_persons(self, inCohortVia: str):
         )
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown=[cohort1.pk, "all"], breakdown_type=BreakdownType.COHORT),
         )
 
@@ -603,7 +603,7 @@ def test_trends_math_weekly_active_persons(self):
             )
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.WEEKLY_ACTIVE)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-28")
@@ -618,7 +618,7 @@ def test_trends_math_property_sum_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=PropertyMathType.SUM, math_property="some_property")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-05-01")
@@ -640,7 +640,7 @@ def test_trends_math_count_per_actor_persons(self):
                     event="$pageview", math=CountPerActorMathType.MAX_COUNT_PER_ACTOR, math_property="some_property"
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-05-01")
@@ -685,7 +685,7 @@ def test_trends_math_group_persons(self):
             series=[
                 EventsNode(event="$pageview", math="unique_group", math_group_type_index=MathGroupTypeIndex.NUMBER_0)
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-05-01")
@@ -720,7 +720,7 @@ def test_trends_math_group_persons_filters_empty(self):
             series=[
                 EventsNode(event="$pageview", math="unique_group", math_group_type_index=MathGroupTypeIndex.NUMBER_0)
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-05-01")
@@ -733,7 +733,7 @@ def test_trends_total_value_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             trendsFilter=TrendsFilter(display=ChartDisplayType.BOLD_NUMBER),
         )
 
@@ -751,7 +751,7 @@ def test_trends_compare_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             trendsFilter=TrendsFilter(),
             compareFilter=CompareFilter(compare=True),
         )
@@ -774,7 +774,7 @@ def test_trends_event_multiple_breakdowns_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdowns=[Breakdown(property="$browser")]),
         )
 
@@ -794,7 +794,7 @@ def test_trends_person_multiple_breakdown_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="$geoip_country_code", type=BreakdownType.PERSON)]
             ),
@@ -816,7 +816,7 @@ def test_trends_multiple_breakdown_null_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="$browser")],
                 breakdown_limit=1,
@@ -839,7 +839,7 @@ def test_trends_multiple_breakdowns_hogql_persons(self):
         self._create_events()
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="properties.some_property", type=BreakdownType.HOGQL)],
                 breakdown_limit=1,
@@ -860,7 +860,7 @@ def test_trends_breakdown_filter_by_range(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdown="some_property",
                 breakdown_histogram_bin_count=4,
@@ -895,7 +895,7 @@ def test_trends_multiple_breakdowns_filter_by_range(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdowns=[Breakdown(property="some_property", histogram_bin_count=4)]),
         )
 
@@ -962,7 +962,7 @@ def test_trends_breakdown_by_boolean(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="bool")],
                 breakdown_limit=1,
@@ -980,7 +980,7 @@ def test_trends_breakdown_by_boolean(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview")],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdown="bool",
                 breakdown_limit=1,
@@ -1001,7 +1001,7 @@ def test_trends_math_first_time_for_user_basic(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         for i in range(4):
@@ -1033,7 +1033,7 @@ def test_trends_math_first_time_for_user_breakdowns_basic(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="$browser"),
         )
 
@@ -1057,7 +1057,7 @@ def test_trends_math_first_time_for_user_breakdowns_basic(self):
 
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="$browser", type=MultipleBreakdownType.EVENT)]
             ),
@@ -1087,7 +1087,7 @@ def test_trends_math_first_time_for_user_numeric_breakdowns(self):
         # single breakdown and bins
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="some_property", breakdown_histogram_bin_count=4),
         )
 
@@ -1112,7 +1112,7 @@ def test_trends_math_first_time_for_user_numeric_breakdowns(self):
         # single breakdown and just numbers
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(breakdown="some_property"),
         )
 
@@ -1127,7 +1127,7 @@ def test_trends_math_first_time_for_user_numeric_breakdowns(self):
         # multiple breakdowns and bins
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[
                     Breakdown(property="some_property", type=MultipleBreakdownType.EVENT, histogram_bin_count=4)
@@ -1156,7 +1156,7 @@ def test_trends_math_first_time_for_user_numeric_breakdowns(self):
         # multiple breakdowns and just numbers
         source_query = TrendsQuery(
             series=[EventsNode(event="$pageview", math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             breakdownFilter=BreakdownFilter(
                 breakdowns=[Breakdown(property="some_property", type=MultipleBreakdownType.EVENT)]
             ),
@@ -1181,7 +1181,7 @@ def test_trends_math_first_time_for_user_with_filters(self):
                     properties=[EventPropertyFilter(key="$browser", operator=PropertyOperator.EXACT, value="Chrome")],
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-29")
@@ -1201,7 +1201,7 @@ def test_trends_math_first_time_for_user_with_filters(self):
                     ],
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-29")
@@ -1283,7 +1283,7 @@ def test_trends_math_first_time_for_user_handles_multiple_ids(self):
                     math=BaseMathType.FIRST_TIME_FOR_USER,
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
             trendsFilter=TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH),
         )
 
@@ -1335,7 +1335,7 @@ def test_trends_math_first_time_for_user_matches_first_event_only(self):
                     properties=[EventPropertyFilter(key="$browser", operator=PropertyOperator.EXACT, value="Chrome")],
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2020-01-11")
@@ -1353,7 +1353,7 @@ def test_trends_math_first_time_for_user_matches_first_event_only(self):
                     properties=[EventPropertyFilter(key="$browser", operator=PropertyOperator.EXACT, value="Safari")],
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2020-01-11")
@@ -1396,7 +1396,7 @@ def test_trends_math_first_time_for_user_matches_all_first_events(self):
                     properties=[EventPropertyFilter(key="$browser", operator=PropertyOperator.EXACT, value="Chrome")],
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2020-01-11")
@@ -1414,7 +1414,7 @@ def test_trends_math_first_time_for_user_matches_all_first_events(self):
                     properties=[EventPropertyFilter(key="$browser", operator=PropertyOperator.EXACT, value="Safari")],
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2020-01-11")
@@ -1435,7 +1435,7 @@ def test_trends_math_first_time_for_user_month_interval(self):
                     math=BaseMathType.FIRST_TIME_FOR_USER,
                 )
             ],
-            dateRange=InsightDateRange(date_from="-180d"),
+            dateRange=DateRange(date_from="-180d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-03-01")
@@ -1465,7 +1465,7 @@ def test_trends_math_first_time_for_user_day_interval(self):
                     math=BaseMathType.FIRST_TIME_FOR_USER,
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-29")
@@ -1495,7 +1495,7 @@ def test_trends_math_first_time_for_user_week_interval(self):
                     math=BaseMathType.FIRST_TIME_FOR_USER,
                 )
             ],
-            dateRange=InsightDateRange(date_from="-90d"),
+            dateRange=DateRange(date_from="-90d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-24")
@@ -1525,7 +1525,7 @@ def test_trends_math_first_time_for_user_hour_interval(self):
                     math=BaseMathType.FIRST_TIME_FOR_USER,
                 )
             ],
-            dateRange=InsightDateRange(date_from="-7d"),
+            dateRange=DateRange(date_from="-7d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-29T16:00:00Z")
@@ -1563,7 +1563,7 @@ def test_trends_math_first_time_for_user_minute_interval(self):
                     math=BaseMathType.FIRST_TIME_FOR_USER,
                 )
             ],
-            dateRange=InsightDateRange(date_from="-1h"),
+            dateRange=DateRange(date_from="-1h"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-29T16:00:00Z")
@@ -1596,7 +1596,7 @@ def test_trends_math_first_time_for_user_all_events(self):
         source_query = TrendsQuery(
             interval=IntervalType.MONTH,
             series=[EventsNode(math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-180d"),
+            dateRange=DateRange(date_from="-180d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-01")
@@ -1653,7 +1653,7 @@ def test_trends_math_first_time_for_user_actions(self):
         source_query = TrendsQuery(
             interval=IntervalType.MONTH,
             series=[ActionsNode(id=action.id, math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-180d"),
+            dateRange=DateRange(date_from="-180d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-01")
@@ -1692,7 +1692,7 @@ def test_trends_math_first_time_for_user_actions(self):
         source_query = TrendsQuery(
             interval=IntervalType.MONTH,
             series=[ActionsNode(id=action.id, math=BaseMathType.FIRST_TIME_FOR_USER)],
-            dateRange=InsightDateRange(date_from="-180d"),
+            dateRange=DateRange(date_from="-180d"),
         )
 
         result = self._get_actors(trends_query=source_query, day="2023-04-01")
diff --git a/posthog/hogql_queries/insights/trends/test/test_trends_query_builder.py b/posthog/hogql_queries/insights/trends/test/test_trends_query_builder.py
index 4826813cb54de..832c6932a0afd 100644
--- a/posthog/hogql_queries/insights/trends/test/test_trends_query_builder.py
+++ b/posthog/hogql_queries/insights/trends/test/test_trends_query_builder.py
@@ -11,7 +11,7 @@
     BreakdownFilter,
     BreakdownType,
     ChartDisplayType,
-    InsightDateRange,
+    DateRange,
     DataWarehouseNode,
     EventsNode,
     HogQLQueryResponse,
@@ -73,7 +73,7 @@ def get_response(self, trends_query: TrendsQuery) -> HogQLQueryResponse:
     def test_column_names(self):
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[EventsNode(event="$pageview", math=BaseMathType.TOTAL)],
         )
 
@@ -85,7 +85,7 @@ def test_column_names(self):
     def assert_column_names_with_display_type(self, display_type: ChartDisplayType):
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[EventsNode(event="$pageview")],
             trendsFilter=TrendsFilter(display=display_type),
         )
@@ -98,7 +98,7 @@ def assert_column_names_with_display_type(self, display_type: ChartDisplayType):
     def assert_column_names_with_display_type_and_breakdowns(self, display_type: ChartDisplayType):
         trends_query = TrendsQuery(
             kind="TrendsQuery",
-            dateRange=InsightDateRange(date_from="2023-01-01"),
+            dateRange=DateRange(date_from="2023-01-01"),
             series=[EventsNode(event="$pageview")],
             trendsFilter=TrendsFilter(display=display_type),
             breakdownFilter=BreakdownFilter(breakdown="$geoip_country_code", breakdown_type=BreakdownType.EVENT),
diff --git a/posthog/hogql_queries/insights/trends/test/test_trends_query_runner.py b/posthog/hogql_queries/insights/trends/test/test_trends_query_runner.py
index 1f22f88de60a9..11d7a183a266f 100644
--- a/posthog/hogql_queries/insights/trends/test/test_trends_query_runner.py
+++ b/posthog/hogql_queries/insights/trends/test/test_trends_query_runner.py
@@ -30,6 +30,7 @@
 from posthog.models.cohort.cohort import Cohort
 from posthog.models.group.util import create_group
 from posthog.models.property_definition import PropertyDefinition
+from posthog.models.team.team import Team
 from posthog.schema import (
     ActionsNode,
     BaseMathType,
@@ -46,7 +47,7 @@
     EventsNode,
     HogQLQueryModifiers,
     InCohortVia,
-    InsightDateRange,
+    DateRange,
     IntervalType,
     MultipleBreakdownType,
     PersonPropertyFilter,
@@ -358,7 +359,7 @@ def _create_query_runner(
     ) -> TrendsQueryRunner:
         query_series: list[EventsNode | ActionsNode] = [EventsNode(event="$pageview")] if series is None else series
         query = TrendsQuery(
-            dateRange=InsightDateRange(date_from=date_from, date_to=date_to, explicitDate=explicit_date),
+            dateRange=DateRange(date_from=date_from, date_to=date_to, explicitDate=explicit_date),
             interval=interval,
             series=query_series,
             trendsFilter=trends_filters,
@@ -859,6 +860,67 @@ def test_formula_with_breakdown_and_compare_total_value(self):
         assert response.results[2]["breakdown_value"] == "Chrome"
         assert response.results[2]["aggregated_value"] == 9
 
+    def test_trends_with_cohort_filter(self):
+        self._create_test_events()
+        cohort = Cohort.objects.create(
+            team=self.team,
+            groups=[
+                {
+                    "properties": [
+                        {
+                            "key": "name",
+                            "value": "p1",
+                            "type": "person",
+                        }
+                    ]
+                }
+            ],
+            name="cohort p1",
+        )
+        cohort.calculate_people_ch(pending_version=0)
+
+        response = self._run_trends_query(
+            "2020-01-09",
+            "2020-01-20",
+            IntervalType.DAY,
+            [EventsNode(event="$pageview", properties=[{"key": "id", "value": cohort.pk, "type": "cohort"}])],
+        )
+
+        assert len(response.results) == 1
+        assert response.results[0]["count"] == 6
+        assert response.results[0]["data"] == [0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]
+
+    def test_trends_with_cohort_filter_other_team_in_project(self):
+        self._create_test_events()
+        other_team_in_project = Team.objects.create(organization=self.organization, project=self.project)
+        cohort = Cohort.objects.create(
+            team=other_team_in_project,  # Not self.team!
+            groups=[
+                {
+                    "properties": [
+                        {
+                            "key": "name",
+                            "value": "p1",
+                            "type": "person",
+                        }
+                    ]
+                }
+            ],
+            name="cohort p1 other team",
+        )
+        cohort.calculate_people_ch(pending_version=0)
+
+        response = self._run_trends_query(
+            "2020-01-09",
+            "2020-01-20",
+            IntervalType.DAY,
+            [EventsNode(event="$pageview", properties=[{"key": "id", "value": cohort.pk, "type": "cohort"}])],
+        )
+
+        assert len(response.results) == 1
+        assert response.results[0]["count"] == 6
+        assert response.results[0]["data"] == [0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]
+
     def test_formula_with_multi_cohort_breakdown(self):
         self._create_test_events()
         cohort1 = Cohort.objects.create(
@@ -4951,3 +5013,57 @@ def test_trends_aggregation_total_with_null(self):
 
         assert len(response.results) == 1
         assert response.results[0]["data"] == [1.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.1]
+
+    def test_trends_aggregation_first_matching_event_for_user(self):
+        _create_person(
+            team=self.team,
+            distinct_ids=["p1"],
+            properties={},
+        )
+        _create_event(
+            team=self.team,
+            event="$pageview",
+            distinct_id="p1",
+            timestamp="2020-01-08T12:00:00Z",
+            properties={"$browser": "Chrome"},
+        )
+        _create_event(
+            team=self.team,
+            event="$pageview",
+            distinct_id="p1",
+            timestamp="2020-01-09T12:00:00Z",
+            properties={"$browser": "Chrome"},
+        )
+        _create_event(
+            team=self.team,
+            event="$pageview",
+            distinct_id="p1",
+            timestamp="2020-01-10T12:00:00Z",
+            properties={"$browser": "Firefox"},
+        )
+        _create_event(
+            team=self.team,
+            event="$pageview",
+            distinct_id="p1",
+            timestamp="2020-01-11T12:00:00Z",
+            properties={"$browser": "Firefox"},
+        )
+        flush_persons_and_events()
+
+        response = self._run_trends_query(
+            "2020-01-08",
+            "2020-01-11",
+            IntervalType.DAY,
+            [
+                EventsNode(
+                    event="$pageview",
+                    math=BaseMathType.FIRST_MATCHING_EVENT_FOR_USER,
+                    properties=[EventPropertyFilter(key="$browser", operator=PropertyOperator.EXACT, value="Firefox")],
+                )
+            ],
+            TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH),
+        )
+
+        assert len(response.results) == 1
+        assert response.results[0]["count"] == 1
+        assert response.results[0]["data"] == [0, 0, 1, 0]
diff --git a/posthog/hogql_queries/insights/trends/trends_query_builder.py b/posthog/hogql_queries/insights/trends/trends_query_builder.py
index 826d52c1e556f..a0e1b185ce806 100644
--- a/posthog/hogql_queries/insights/trends/trends_query_builder.py
+++ b/posthog/hogql_queries/insights/trends/trends_query_builder.py
@@ -294,14 +294,15 @@ def _get_events_subquery(
 
             return wrapper
         # Just complex series aggregation
-        elif (
-            self._aggregation_operation.requires_query_orchestration()
-            and self._aggregation_operation.is_first_time_ever_math()
+        elif self._aggregation_operation.requires_query_orchestration() and (
+            self._aggregation_operation.is_first_time_ever_math()
+            or self._aggregation_operation.is_first_matching_event()
         ):
             return self._aggregation_operation.get_first_time_math_query_orchestrator(
                 events_where_clause=events_filter,
                 sample_value=self._sample_value(),
                 event_name_filter=self._event_or_action_where_expr(),
+                is_first_matching_event=self._aggregation_operation.is_first_matching_event(),
             ).build()
         elif self._aggregation_operation.requires_query_orchestration():
             return self._aggregation_operation.get_actors_query_orchestrator(
diff --git a/posthog/hogql_queries/insights/trends/trends_query_runner.py b/posthog/hogql_queries/insights/trends/trends_query_runner.py
index 668cd8b2afb48..c7de458195b2f 100644
--- a/posthog/hogql_queries/insights/trends/trends_query_runner.py
+++ b/posthog/hogql_queries/insights/trends/trends_query_runner.py
@@ -219,7 +219,10 @@ def to_actors_query_options(self) -> InsightActorsQueryOptionsResponse:
                 for value in self.query.breakdownFilter.breakdown:
                     if value != "all" and str(value) != "0":
                         res_breakdown.append(
-                            BreakdownItem(label=Cohort.objects.get(pk=int(value), team=self.team).name, value=value)
+                            BreakdownItem(
+                                label=Cohort.objects.get(pk=int(value), team__project_id=self.team.project_id).name,
+                                value=value,
+                            )
                         )
                     else:
                         res_breakdown.append(BreakdownItem(label="all users", value="all"))
diff --git a/posthog/hogql_queries/insights/utils/aggregations.py b/posthog/hogql_queries/insights/utils/aggregations.py
index cb4fd72377759..bdf30f527d921 100644
--- a/posthog/hogql_queries/insights/utils/aggregations.py
+++ b/posthog/hogql_queries/insights/utils/aggregations.py
@@ -68,20 +68,26 @@ def __init__(
         filters: ast.Expr | None = None,
         event_or_action_filter: ast.Expr | None = None,
         ratio: ast.RatioExpr | None = None,
+        is_first_matching_event: bool = False,
     ):
-        query.select = self._select_expr(date_from, filters)
+        query.select = self._select_expr(date_from, filters, is_first_matching_event)
         query.select_from = self._select_from_expr(ratio)
         query.where = self._where_expr(date_to, event_or_action_filter)
         query.group_by = self._group_by_expr()
         query.having = self._having_expr()
         super().__init__(query)
 
-    def _select_expr(self, date_from: ast.Expr, filters: ast.Expr | None = None):
+    def _select_expr(self, date_from: ast.Expr, filters: ast.Expr | None = None, is_first_matching_event: bool = False):
         aggregation_filters = date_from if filters is None else ast.And(exprs=[date_from, filters])
+        min_timestamp_expr = (
+            ast.Call(name="min", args=[ast.Field(chain=["timestamp"])])
+            if not is_first_matching_event or filters is None
+            else ast.Call(name="minIf", args=[ast.Field(chain=["timestamp"]), filters])
+        )
         return [
             ast.Alias(
                 alias="min_timestamp",
-                expr=ast.Call(name="min", args=[ast.Field(chain=["timestamp"])]),
+                expr=min_timestamp_expr,
             ),
             ast.Alias(
                 alias="min_timestamp_with_condition",
diff --git a/posthog/hogql_queries/legacy_compatibility/filter_to_query.py b/posthog/hogql_queries/legacy_compatibility/filter_to_query.py
index a8cc01a0b89fb..42ca783b04bf1 100644
--- a/posthog/hogql_queries/legacy_compatibility/filter_to_query.py
+++ b/posthog/hogql_queries/legacy_compatibility/filter_to_query.py
@@ -2,7 +2,9 @@
 import json
 import re
 from enum import StrEnum
-from typing import Any, Literal
+from typing import Any, Literal, Optional, Union, cast
+
+from pydantic import Field
 
 from posthog.hogql_queries.legacy_compatibility.clean_properties import clean_entity_properties, clean_global_properties
 from posthog.models.entity.entity import Entity as LegacyEntity
@@ -20,11 +22,12 @@
     FunnelsFilter,
     FunnelsQuery,
     FunnelVizType,
-    InsightDateRange,
+    DateRange,
     LifecycleFilter,
     LifecycleQuery,
     PathsFilter,
     PathsQuery,
+    RetentionEntity,
     RetentionFilter,
     RetentionQuery,
     StickinessFilter,
@@ -56,6 +59,10 @@ class MathAvailability(StrEnum):
 ]
 
 
+def is_entity_variable(item: Any) -> bool:
+    return isinstance(item, str) and item.startswith("{") and item.endswith("}")
+
+
 def clean_display(display: str):
     if display not in [c.value for c in ChartDisplayType]:
         return None
@@ -110,8 +117,16 @@ def transform_legacy_hidden_legend_keys(hidden_legend_keys):
 
 
 def legacy_entity_to_node(
-    entity: LegacyEntity, include_properties: bool, math_availability: MathAvailability
-) -> EventsNode | ActionsNode | DataWarehouseNode:
+    entity: LegacyEntity | str,
+    include_properties: bool,
+    math_availability: MathAvailability,
+    allow_variables: bool = False,
+) -> EventsNode | ActionsNode | DataWarehouseNode | str:
+    if allow_variables and is_entity_variable(entity):
+        return cast(str, entity)
+
+    assert not isinstance(entity, str)
+
     """
     Takes a legacy entity and converts it into an EventsNode or ActionsNode.
     """
@@ -172,6 +187,7 @@ def exlusion_entity_to_node(entity) -> FunnelExclusionEventsNode | FunnelExclusi
     base_entity = legacy_entity_to_node(
         LegacyEntity(entity), include_properties=False, math_availability=MathAvailability.Unavailable
     )
+    assert isinstance(base_entity, EventsNode | ActionsNode)
     if isinstance(base_entity, EventsNode):
         return FunnelExclusionEventsNode(
             **base_entity.model_dump(),
@@ -187,7 +203,12 @@ def exlusion_entity_to_node(entity) -> FunnelExclusionEventsNode | FunnelExclusi
 
 
 # TODO: remove this method that returns legacy entities
-def to_base_entity_dict(entity: dict):
+def to_base_entity_dict(entity: dict | str):
+    if isinstance(entity, str):
+        if is_entity_variable(entity):
+            return entity
+        raise ValueError("Expecting valid entity or template variable")
+
     return {
         "type": entity.get("type"),
         "id": entity.get("id"),
@@ -206,11 +227,57 @@ def to_base_entity_dict(entity: dict):
     "STICKINESS": StickinessQuery,
 }
 
+
+class TrendsQueryWithTemplateVariables(TrendsQuery):
+    series: list[Union[EventsNode, ActionsNode, DataWarehouseNode, str]] = Field(  # type: ignore
+        ..., description="Events and actions to include"
+    )
+
+
+class FunnelsQueryWithTemplateVariables(FunnelsQuery):
+    series: list[Union[EventsNode, ActionsNode, DataWarehouseNode, str]] = Field(  # type: ignore
+        ..., description="Events and actions to include"
+    )
+
+
+class RetentionFilterWithTemplateVariables(RetentionFilter):
+    returningEntity: Optional[RetentionEntity | str] = None  # type: ignore
+    targetEntity: Optional[RetentionEntity | str] = None  # type: ignore
+
+
+class RetentionQueryWithTemplateVariables(RetentionQuery):
+    retentionFilter: RetentionFilterWithTemplateVariables = Field(
+        ..., description="Properties specific to the retention insight"
+    )
+
+
+class LifecycleQueryWithTemplateVariables(LifecycleQuery):
+    series: list[Union[EventsNode, ActionsNode, DataWarehouseNode, str]] = Field(  # type: ignore
+        ..., description="Events and actions to include"
+    )
+
+
+class StickinessQueryWithTemplateVariables(StickinessQuery):
+    series: list[Union[EventsNode, ActionsNode, DataWarehouseNode, str]] = Field(  # type: ignore
+        ..., description="Events and actions to include"
+    )
+
+
+#
+insight_to_query_type_with_variables = {
+    "TRENDS": TrendsQueryWithTemplateVariables,
+    "FUNNELS": FunnelsQueryWithTemplateVariables,
+    "RETENTION": RetentionQueryWithTemplateVariables,
+    "PATHS": PathsQuery,
+    "LIFECYCLE": LifecycleQueryWithTemplateVariables,
+    "STICKINESS": StickinessQueryWithTemplateVariables,
+}
+
 INSIGHT_TYPE = Literal["TRENDS", "FUNNELS", "RETENTION", "PATHS", "LIFECYCLE", "STICKINESS"]
 
 
 def _date_range(filter: dict):
-    date_range = InsightDateRange(
+    date_range = DateRange(
         date_from=filter.get("date_from"),
         date_to=filter.get("date_to"),
         explicitDate=str_to_bool(filter.get("explicit_date")) if filter.get("explicit_date") else None,
@@ -232,12 +299,12 @@ def _interval(filter: dict):
     return {"interval": filter.get("interval")}
 
 
-def _series(filter: dict):
+def _series(filter: dict, allow_variables: bool = False):
     if _insight_type(filter) == "RETENTION" or _insight_type(filter) == "PATHS":
         return {}
 
     # remove templates gone wrong
-    if filter.get("events") is not None:
+    if not allow_variables and filter.get("events") is not None:
         filter["events"] = [event for event in filter.get("events") if not (isinstance(event, str))]
 
     math_availability: MathAvailability = MathAvailability.Unavailable
@@ -252,15 +319,16 @@ def _series(filter: dict):
 
     return {
         "series": [
-            legacy_entity_to_node(entity, include_properties, math_availability)
-            for entity in _entities(filter)
-            if not (entity.type == "actions" and entity.id is None)
+            legacy_entity_to_node(entity, include_properties, math_availability, allow_variables)
+            for entity in _entities(filter, allow_variables)
+            if isinstance(entity, str) or not (entity.type == "actions" and entity.id is None)
         ]
     }
 
 
-def _entities(filter: dict):
-    processed_entities: list[LegacyEntity] = []
+def _entities(filter: dict, allow_variables: bool = False):
+    processed_entities: list[LegacyEntity | str] = []
+    has_variables = False
 
     # add actions
     actions = filter.get("actions", [])
@@ -272,7 +340,18 @@ def _entities(filter: dict):
     events = filter.get("events", [])
     if isinstance(events, str):
         events = json.loads(events)
-    processed_entities.extend([LegacyEntity({**entity, "type": "events"}) for entity in events])
+
+    def process_event(entity) -> LegacyEntity | str:
+        nonlocal has_variables
+
+        # strings represent template variables, return them as-is
+        if allow_variables and isinstance(entity, str):
+            has_variables = True
+            return entity
+        else:
+            return LegacyEntity({**entity, "type": "events"})
+
+    processed_entities.extend([process_event(entity) for entity in events])
 
     # add data warehouse
     warehouse = filter.get("data_warehouse", [])
@@ -280,12 +359,13 @@ def _entities(filter: dict):
         warehouse = json.loads(warehouse)
     processed_entities.extend([LegacyEntity({**entity, "type": "data_warehouse"}) for entity in warehouse])
 
-    # order by order
-    processed_entities.sort(key=lambda entity: entity.order if entity.order else -1)
+    if not has_variables:
+        # order by order
+        processed_entities.sort(key=lambda entity: entity.order if entity.order else -1)  # type: ignore
 
-    # set sequential index values on entities
-    for index, entity in enumerate(processed_entities):
-        entity.index = index
+        # set sequential index values on entities
+        for index, entity in enumerate(processed_entities):
+            entity.index = index  # type: ignore
 
     return processed_entities
 
@@ -394,7 +474,7 @@ def _group_aggregation_filter(filter: dict):
     return {"aggregation_group_type_index": filter.get("aggregation_group_type_index")}
 
 
-def _insight_filter(filter: dict):
+def _insight_filter(filter: dict, allow_variables: bool = False):
     if _insight_type(filter) == "TRENDS":
         insight_filter = {
             "trendsFilter": TrendsFilter(
@@ -440,18 +520,19 @@ def _insight_filter(filter: dict):
             ),
         }
     elif _insight_type(filter) == "RETENTION":
+        RetentionFilterClass = RetentionFilterWithTemplateVariables if allow_variables else RetentionFilter
         insight_filter = {
-            "retentionFilter": RetentionFilter(
+            "retentionFilter": RetentionFilterClass(
                 retentionType=filter.get("retention_type"),
                 retentionReference=filter.get("retention_reference"),
                 totalIntervals=filter.get("total_intervals"),
                 returningEntity=(
-                    to_base_entity_dict(filter.get("returning_entity"))
+                    to_base_entity_dict(filter.get("returning_entity"))  # type: ignore
                     if filter.get("returning_entity") is not None
                     else None
                 ),
                 targetEntity=(
-                    to_base_entity_dict(filter.get("target_entity"))
+                    to_base_entity_dict(filter.get("target_entity"))  # type: ignore
                     if filter.get("target_entity") is not None
                     else None
                 ),
@@ -526,22 +607,26 @@ def _insight_type(filter: dict) -> INSIGHT_TYPE:
     return filter.get("insight", "TRENDS")
 
 
-def filter_to_query(filter: dict) -> InsightQueryNode:
+def filter_to_query(filter: dict, allow_variables: bool = False) -> InsightQueryNode:
     filter = copy.deepcopy(filter)  # duplicate to prevent accidental filter alterations
 
-    Query = insight_to_query_type[_insight_type(filter)]
+    Query = (
+        insight_to_query_type_with_variables[_insight_type(filter)]
+        if allow_variables
+        else insight_to_query_type[_insight_type(filter)]
+    )
 
     data = {
         **_date_range(filter),
         **_interval(filter),
-        **_series(filter),
+        **_series(filter, allow_variables),
         **_sampling_factor(filter),
         **_filter_test_accounts(filter),
         **_properties(filter),
         **_breakdown_filter(filter),
         **_compare_filter(filter),
         **_group_aggregation_filter(filter),
-        **_insight_filter(filter),
+        **_insight_filter(filter, allow_variables),
     }
 
     # :KLUDGE: We do this dance to have default values instead of None, when setting
diff --git a/posthog/hogql_queries/legacy_compatibility/test/test_filter_to_query.py b/posthog/hogql_queries/legacy_compatibility/test/test_filter_to_query.py
index b0e9e6a6c4ec9..9ba7c48f80c2a 100644
--- a/posthog/hogql_queries/legacy_compatibility/test/test_filter_to_query.py
+++ b/posthog/hogql_queries/legacy_compatibility/test/test_filter_to_query.py
@@ -1,3 +1,4 @@
+from typing import cast
 import pytest
 
 from posthog.hogql_queries.legacy_compatibility.filter_to_query import (
@@ -31,7 +32,7 @@
     FunnelVizType,
     GroupPropertyFilter,
     HogQLPropertyFilter,
-    InsightDateRange,
+    DateRange,
     Key,
     LifecycleFilter,
     LifecycleQuery,
@@ -927,7 +928,7 @@ def test_full_trend(self):
 
         self.assertEqual(
             query.model_dump(exclude_defaults=True),
-            {"breakdownFilter": {}, "dateRange": {}, "series": [], "trendsFilter": {}},
+            {"breakdownFilter": {}, "dateRange": {}, "compareFilter": {}, "series": [], "trendsFilter": {}},
         )
 
     def test_base_funnel(self):
@@ -970,7 +971,7 @@ def test_date_range(self):
 
         query = filter_to_query(filter)
 
-        assert isinstance(query.dateRange, InsightDateRange)
+        assert isinstance(query.dateRange, DateRange)
         self.assertEqual(query.dateRange.date_from, "-14d")
         self.assertEqual(query.dateRange.date_to, "-7d")
 
@@ -979,7 +980,7 @@ def test_date_range_with_explict_date_setting(self):
 
         query = filter_to_query(filter)
 
-        assert isinstance(query.dateRange, InsightDateRange)
+        assert isinstance(query.dateRange, DateRange)
         self.assertEqual(query.dateRange.date_from, "-14d")
         self.assertEqual(query.dateRange.date_to, "-7d")
         self.assertEqual(query.dateRange.explicitDate, True)
@@ -1604,7 +1605,7 @@ def test_paths_filter(self):
                     filterTestAccounts=True,
                     funnelsFilter=FunnelsFilter(funnelVizType=FunnelVizType.STEPS, exclusions=[]),
                     breakdownFilter=BreakdownFilter(),
-                    dateRange=InsightDateRange(),
+                    dateRange=DateRange(),
                 ),
                 funnelStep=2,
             ),
@@ -1820,3 +1821,37 @@ def test_ignores_digit_only_keys(self):
         indexes = hidden_legend_keys_to_breakdowns(hidden_legend_keys)
 
         self.assertEqual(indexes, ["Opera"])
+
+
+class TestDashboardTemplateConversion(BaseTest):
+    def test_trend_series_with_variables(self):
+        filter = {
+            "insight": "TRENDS",
+            "events": ["{VARIABLE}"],
+        }
+
+        query = cast(TrendsQuery, filter_to_query(filter, allow_variables=True))
+
+        self.assertEqual(query.series, ["{VARIABLE}"])
+
+    def test_funnel_series_with_variables(self):
+        filter = {
+            "insight": "FUNNELS",
+            "events": ["{VARIABLE1}", "{VARIABLE2}"],
+        }
+
+        query = cast(FunnelsQuery, filter_to_query(filter, allow_variables=True))
+
+        self.assertEqual(query.series, ["{VARIABLE1}", "{VARIABLE2}"])
+
+    def test_retention_entities_with_variables(self):
+        filter = {
+            "insight": "RETENTION",
+            "target_entity": "{VARIABLE1}",
+            "returning_entity": "{VARIABLE2}",
+        }
+
+        query = cast(RetentionQuery, filter_to_query(filter, allow_variables=True))
+
+        self.assertEqual(query.retentionFilter.targetEntity, "{VARIABLE1}")
+        self.assertEqual(query.retentionFilter.returningEntity, "{VARIABLE2}")
diff --git a/posthog/hogql_queries/query_runner.py b/posthog/hogql_queries/query_runner.py
index bcc091e516203..abcaddde2d3cf 100644
--- a/posthog/hogql_queries/query_runner.py
+++ b/posthog/hogql_queries/query_runner.py
@@ -704,7 +704,7 @@ def to_actors_query(self, *args, **kwargs) -> ast.SelectQuery | ast.SelectSetQue
         # TODO: add support for selecting and filtering by breakdowns
         raise NotImplementedError()
 
-    def to_hogql(self) -> str:
+    def to_hogql(self, **kwargs) -> str:
         with self.timings.measure("to_hogql"):
             return print_ast(
                 self.to_query(),
@@ -715,6 +715,7 @@ def to_hogql(self) -> str:
                     modifiers=self.modifiers,
                 ),
                 "hogql",
+                **kwargs,
             )
 
     def get_cache_payload(self) -> dict:
diff --git a/posthog/hogql_queries/test/__snapshots__/test_actors_query_runner.ambr b/posthog/hogql_queries/test/__snapshots__/test_actors_query_runner.ambr
index b98c8fab5986f..0735d15369785 100644
--- a/posthog/hogql_queries/test/__snapshots__/test_actors_query_runner.ambr
+++ b/posthog/hogql_queries/test/__snapshots__/test_actors_query_runner.ambr
@@ -2,12 +2,12 @@
 # name: TestActorsQueryRunner.test_persons_query_search_snapshot
   '''
   
-  SELECT id, id, created_at, 1 
+  SELECT id, id, 1 
   FROM persons 
   WHERE or(ilike(properties.email, '%SEARCHSTRING%'), ilike(properties.name, '%SEARCHSTRING%'), ilike(toString(id), '%SEARCHSTRING%'), in(id, (
   SELECT person_id 
   FROM person_distinct_ids 
-  WHERE ilike(distinct_id, '%SEARCHSTRING%')))) ORDER BY created_at DESC 
+  WHERE ilike(distinct_id, '%SEARCHSTRING%')))) ORDER BY id ASC 
   LIMIT 50000
   '''
 # ---
diff --git a/posthog/hogql_queries/test/__snapshots__/test_error_tracking_query_runner.ambr b/posthog/hogql_queries/test/__snapshots__/test_error_tracking_query_runner.ambr
index a23c828bb8864..20abb16f555dd 100644
--- a/posthog/hogql_queries/test/__snapshots__/test_error_tracking_query_runner.ambr
+++ b/posthog/hogql_queries/test/__snapshots__/test_error_tracking_query_runner.ambr
@@ -1,4 +1,32 @@
 # serializer version: 1
+# name: TestErrorTrackingQueryRunner.test_assignee_groups
+  '''
+  SELECT count(DISTINCT events.uuid) AS occurrences,
+         count(DISTINCT events.`$session_id`) AS sessions,
+         count(DISTINCT events.distinct_id) AS users,
+         max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
+         min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
+  FROM events
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), 1)
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
+  LIMIT 101
+  OFFSET 0 SETTINGS readonly=2,
+                    max_execution_time=60,
+                    allow_experimental_object_type=1,
+                    format_csv_allow_double_quotes=0,
+                    max_ast_elements=4000000,
+                    max_expanded_ast_elements=4000000,
+                    max_bytes_before_external_group_by=0
+  '''
+# ---
 # name: TestErrorTrackingQueryRunner.test_column_names
   '''
   SELECT count(DISTINCT events.uuid) AS occurrences,
@@ -6,7 +34,7 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
   LEFT OUTER JOIN
     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -15,6 +43,13 @@
      WHERE equals(person_distinct_id_overrides.team_id, 99999)
      GROUP BY person_distinct_id_overrides.distinct_id
      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
   LEFT JOIN
     (SELECT person.id AS id,
             replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
@@ -25,8 +60,8 @@
                                                            WHERE equals(person.team_id, 99999)
                                                            GROUP BY person.id
                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
                     max_execution_time=60,
@@ -44,7 +79,7 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
   LEFT OUTER JOIN
     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -53,6 +88,13 @@
      WHERE equals(person_distinct_id_overrides.team_id, 99999)
      GROUP BY person_distinct_id_overrides.distinct_id
      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
   LEFT JOIN
     (SELECT person.id AS id,
             replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
@@ -63,8 +105,8 @@
                                                            WHERE equals(person.team_id, 99999)
                                                            GROUP BY person.id
                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), '01936e7f-d7ff-7314-b2d4-7627981e34f0'), 0))
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1), ifNull(equals(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')), '01936e7f-d7ff-7314-b2d4-7627981e34f0'), 0))
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
                     max_execution_time=60,
@@ -82,7 +124,7 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
   LEFT OUTER JOIN
     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -91,6 +133,13 @@
      WHERE equals(person_distinct_id_overrides.team_id, 99999)
      GROUP BY person_distinct_id_overrides.distinct_id
      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
   LEFT JOIN
     (SELECT person.id AS id,
             replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
@@ -101,8 +150,8 @@
                                                            WHERE equals(person.team_id, 99999)
                                                            GROUP BY person.id
                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), ifNull(equals(events__person.properties___email, 'email@posthog.com'), 0))
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), ifNull(equals(events__person.properties___email, 'email@posthog.com'), 0))
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
                     max_execution_time=60,
@@ -120,10 +169,17 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), 1, ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), '01936e7f-d7ff-7314-b2d4-7627981e34f0'), 0))
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), 1, ifNull(equals(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')), '01936e7f-d7ff-7314-b2d4-7627981e34f0'), 0))
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
                     max_execution_time=60,
@@ -141,10 +197,17 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), 1)
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), 1)
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   ORDER BY last_seen DESC
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
@@ -163,10 +226,17 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), 1)
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), 1)
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   ORDER BY first_seen ASC
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
@@ -185,7 +255,7 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
   LEFT OUTER JOIN
     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -194,6 +264,13 @@
      WHERE equals(person_distinct_id_overrides.team_id, 99999)
      GROUP BY person_distinct_id_overrides.distinct_id
      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
   LEFT JOIN
     (SELECT person.id AS id,
             replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
@@ -204,8 +281,8 @@
                                                            WHERE equals(person.team_id, 99999)
                                                            GROUP BY person.id
                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), and(less(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-01-11 00:00:00.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-01-10 00:00:00.000000', 6, 'UTC')), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1)), or(ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_list'), ''), 'null'), '^"|"$', '')), lower('databasenot')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_type'), ''), 'null'), '^"|"$', '')), lower('databasenot')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_message'), ''), 'null'), '^"|"$', '')), lower('databasenot')), 0), 0)))
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), and(less(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-01-11 00:00:00.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-01-10 00:00:00.000000', 6, 'UTC')), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1)), or(ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_list'), ''), 'null'), '^"|"$', '')), lower('databasenot')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_type'), ''), 'null'), '^"|"$', '')), lower('databasenot')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_message'), ''), 'null'), '^"|"$', '')), lower('databasenot')), 0), 0)))
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
                     max_execution_time=60,
@@ -223,7 +300,7 @@
          count(DISTINCT events.distinct_id) AS users,
          max(toTimeZone(events.timestamp, 'UTC')) AS last_seen,
          min(toTimeZone(events.timestamp, 'UTC')) AS first_seen,
-         replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '') AS id
+         if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID')) AS id
   FROM events
   LEFT OUTER JOIN
     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
@@ -232,6 +309,13 @@
      WHERE equals(person_distinct_id_overrides.team_id, 99999)
      GROUP BY person_distinct_id_overrides.distinct_id
      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+  LEFT OUTER JOIN
+    (SELECT argMax(error_tracking_issue_fingerprint_overrides.issue_id, error_tracking_issue_fingerprint_overrides.version) AS issue_id,
+            error_tracking_issue_fingerprint_overrides.fingerprint AS fingerprint
+     FROM error_tracking_issue_fingerprint_overrides
+     WHERE equals(error_tracking_issue_fingerprint_overrides.team_id, 99999)
+     GROUP BY error_tracking_issue_fingerprint_overrides.fingerprint
+     HAVING ifNull(equals(argMax(error_tracking_issue_fingerprint_overrides.is_deleted, error_tracking_issue_fingerprint_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__exception_issue_override ON equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_fingerprint'), ''), 'null'), '^"|"$', ''), events__exception_issue_override.fingerprint)
   LEFT JOIN
     (SELECT person.id AS id,
             replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
@@ -242,8 +326,8 @@
                                                            WHERE equals(person.team_id, 99999)
                                                            GROUP BY person.id
                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1), and(or(ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_list'), ''), 'null'), '^"|"$', '')), lower('databasenotfoundX')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_type'), ''), 'null'), '^"|"$', '')), lower('databasenotfoundX')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_message'), ''), 'null'), '^"|"$', '')), lower('databasenotfoundX')), 0), 0)), or(ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_list'), ''), 'null'), '^"|"$', '')), lower('clickhouse/client/execute.py')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_type'), ''), 'null'), '^"|"$', '')), lower('clickhouse/client/execute.py')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_message'), ''), 'null'), '^"|"$', '')), lower('clickhouse/client/execute.py')), 0), 0))))
-  GROUP BY replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', '')
+  WHERE and(equals(events.team_id, 99999), equals(events.event, '$exception'), isNotNull(if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1), and(or(ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_list'), ''), 'null'), '^"|"$', '')), lower('databasenotfoundX')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_type'), ''), 'null'), '^"|"$', '')), lower('databasenotfoundX')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_message'), ''), 'null'), '^"|"$', '')), lower('databasenotfoundX')), 0), 0)), or(ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_list'), ''), 'null'), '^"|"$', '')), lower('clickhouse/client/execute.py')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_type'), ''), 'null'), '^"|"$', '')), lower('clickhouse/client/execute.py')), 0), 0), ifNull(greater(position(lower(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_message'), ''), 'null'), '^"|"$', '')), lower('clickhouse/client/execute.py')), 0), 0))))
+  GROUP BY if(not(empty(events__exception_issue_override.issue_id)), events__exception_issue_override.issue_id, accurateCastOrNull(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$exception_issue_id'), ''), 'null'), '^"|"$', ''), 'UUID'))
   LIMIT 101
   OFFSET 0 SETTINGS readonly=2,
                     max_execution_time=60,
diff --git a/posthog/hogql_queries/test/test_actors_query_runner.py b/posthog/hogql_queries/test/test_actors_query_runner.py
index 904c1adad8d9f..889896ae239a5 100644
--- a/posthog/hogql_queries/test/test_actors_query_runner.py
+++ b/posthog/hogql_queries/test/test_actors_query_runner.py
@@ -1,3 +1,5 @@
+from typing import cast
+
 import pytest
 
 from posthog.hogql import ast
@@ -12,7 +14,7 @@
     PropertyOperator,
     HogQLQuery,
     LifecycleQuery,
-    InsightDateRange,
+    DateRange,
     EventsNode,
     IntervalType,
     InsightActorsQuery,
@@ -66,19 +68,19 @@ def test_default_persons_query(self):
         runner = self._create_runner(ActorsQuery())
 
         query = runner.to_query()
-        query = clear_locations(query)
+        query = cast(ast.SelectQuery, clear_locations(query))
         expected = ast.SelectQuery(
             select=[
                 ast.Field(chain=["id"]),
                 ast.Field(chain=["id"]),
-                ast.Field(chain=["created_at"]),
                 ast.Constant(value=1),
             ],
             select_from=ast.JoinExpr(table=ast.Field(chain=["persons"])),
             where=None,
-            order_by=[ast.OrderExpr(expr=ast.Field(chain=["created_at"]), order="DESC")],
+            order_by=[ast.OrderExpr(expr=ast.Field(chain=["id"]), order="ASC")],
         )
-        assert clear_locations(query) == expected
+        query.settings = None
+        assert query == expected
         response = runner.calculate()
         assert len(response.results) == 10
 
@@ -225,7 +227,7 @@ def test_source_lifecycle_query(self):
                     )
                 ],
                 interval=IntervalType.DAY,
-                dateRange=InsightDateRange(date_from="-7d"),
+                dateRange=DateRange(date_from="-7d"),
             )
             query = ActorsQuery(
                 select=["properties.email"],
diff --git a/posthog/hogql_queries/test/test_error_tracking_query_runner.py b/posthog/hogql_queries/test/test_error_tracking_query_runner.py
index 2b8bb4e78f83a..6e15387162643 100644
--- a/posthog/hogql_queries/test/test_error_tracking_query_runner.py
+++ b/posthog/hogql_queries/test/test_error_tracking_query_runner.py
@@ -1,5 +1,7 @@
 from unittest import TestCase
 from freezegun import freeze_time
+from datetime import datetime
+from zoneinfo import ZoneInfo
 
 from dateutil.relativedelta import relativedelta
 from django.utils.timezone import now
@@ -14,7 +16,13 @@
     PersonPropertyFilter,
     PropertyOperator,
 )
-from posthog.models.error_tracking import ErrorTrackingIssue
+from posthog.models.error_tracking import (
+    ErrorTrackingIssue,
+    ErrorTrackingIssueFingerprintV2,
+    ErrorTrackingIssueAssignment,
+    update_error_tracking_issue_fingerprints,
+    override_error_tracking_issue_fingerprint,
+)
 from posthog.test.base import (
     APIBaseTest,
     ClickhouseTestMixin,
@@ -24,6 +32,7 @@
     flush_persons_and_events,
 )
 
+
 SAMPLE_STACK_TRACE = [
     {
         "abs_path": "/code/posthog/clickhouse/client/execute.py",
@@ -186,12 +195,22 @@
 class TestErrorTrackingQueryRunner(ClickhouseTestMixin, APIBaseTest):
     distinct_id_one = "user_1"
     distinct_id_two = "user_2"
-    issue_one = "01936e7f-d7ff-7314-b2d4-7627981e34f0"
-    issue_two = "01936e80-5e69-7e70-b837-871f5cdad28b"
-    issue_three = "01936e80-aa51-746f-aec4-cdf16a5c5332"
+    issue_id_one = "01936e7f-d7ff-7314-b2d4-7627981e34f0"
+    issue_id_two = "01936e80-5e69-7e70-b837-871f5cdad28b"
+    issue_id_three = "01936e80-aa51-746f-aec4-cdf16a5c5332"
+    issue_three_fingerprint = "issue_three_fingerprint"
+
+    def override_fingerprint(self, fingerprint, issue_id, version=1):
+        update_error_tracking_issue_fingerprints(team_id=self.team.pk, issue_id=issue_id, fingerprints=[fingerprint])
+        override_error_tracking_issue_fingerprint(
+            team_id=self.team.pk, fingerprint=fingerprint, issue_id=issue_id, version=version
+        )
 
-    def create_events_and_issue(self, issue_id, distinct_ids, timestamp=None, exception_list=None):
-        event_properties = {"$exception_issue_id": issue_id}
+    def create_events_and_issue(self, issue_id, fingerprint, distinct_ids, timestamp=None, exception_list=None):
+        issue = ErrorTrackingIssue.objects.create(id=issue_id, team=self.team)
+        ErrorTrackingIssueFingerprintV2.objects.create(team=self.team, issue=issue, fingerprint=fingerprint)
+
+        event_properties = {"$exception_issue_id": issue_id, "$exception_fingerprint": fingerprint}
         if exception_list:
             event_properties["$exception_list"] = exception_list
 
@@ -204,8 +223,6 @@ def create_events_and_issue(self, issue_id, distinct_ids, timestamp=None, except
                 timestamp=timestamp,
             )
 
-        ErrorTrackingIssue.objects.create(id=issue_id, team=self.team)
-
     def setUp(self):
         super().setUp()
 
@@ -225,16 +242,23 @@ def setUp(self):
                 is_identified=True,
             )
 
-            self.create_events_and_issue(
-                issue_id=self.issue_one,
+            self.issue_one = self.create_events_and_issue(
+                issue_id=self.issue_id_one,
+                fingerprint="issue_one_fingerprint",
                 distinct_ids=[self.distinct_id_one, self.distinct_id_two],
                 timestamp=now() - relativedelta(hours=3),
             )
             self.create_events_and_issue(
-                issue_id=self.issue_two, distinct_ids=[self.distinct_id_one], timestamp=now() - relativedelta(hours=2)
+                issue_id=self.issue_id_two,
+                fingerprint="issue_two_fingerprint",
+                distinct_ids=[self.distinct_id_one],
+                timestamp=now() - relativedelta(hours=2),
             )
             self.create_events_and_issue(
-                issue_id=self.issue_three, distinct_ids=[self.distinct_id_two], timestamp=now() - relativedelta(hours=1)
+                issue_id=self.issue_id_three,
+                fingerprint=self.issue_three_fingerprint,
+                distinct_ids=[self.distinct_id_two],
+                timestamp=now() - relativedelta(hours=1),
             )
 
         flush_persons_and_events()
@@ -271,7 +295,7 @@ def test_column_names(self):
             team=self.team,
             query=ErrorTrackingQuery(
                 kind="ErrorTrackingQuery",
-                issueId=self.issue_one,
+                issueId=self.issue_id_one,
                 dateRange=DateRange(),
                 filterTestAccounts=True,
             ),
@@ -296,7 +320,7 @@ def test_issue_grouping(self):
             team=self.team,
             query=ErrorTrackingQuery(
                 kind="ErrorTrackingQuery",
-                issueId=self.issue_one,
+                issueId=self.issue_id_one,
                 dateRange=DateRange(),
             ),
         )
@@ -304,7 +328,7 @@ def test_issue_grouping(self):
         results = self._calculate(runner)["results"]
         # returns a single group with multiple errors
         self.assertEqual(len(results), 1)
-        self.assertEqual(results[0]["id"], self.issue_one)
+        self.assertEqual(results[0]["id"], self.issue_id_one)
         self.assertEqual(results[0]["occurrences"], 2)
 
     @snapshot_clickhouse_queries
@@ -312,16 +336,19 @@ def test_search_query(self):
         with freeze_time("2022-01-10 12:11:00"):
             self.create_events_and_issue(
                 issue_id="01936e81-b0ce-7b56-8497-791e505b0d0c",
+                fingerprint="fingerprint_DatabaseNotFoundX",
                 distinct_ids=[self.distinct_id_one],
                 exception_list=[{"type": "DatabaseNotFoundX", "value": "this is the same error message"}],
             )
             self.create_events_and_issue(
                 issue_id="01936e81-f5ce-79b1-99f1-f0e9675fcfef",
+                fingerprint="fingerprint_DatabaseNotFoundY",
                 distinct_ids=[self.distinct_id_one],
                 exception_list=[{"type": "DatabaseNotFoundY", "value": "this is the same error message"}],
             )
             self.create_events_and_issue(
                 issue_id="01936e82-241e-7e27-b47d-6659c54eb0be",
+                fingerprint="fingerprint_xyz",
                 distinct_ids=[self.distinct_id_two],
                 exception_list=[{"type": "xyz", "value": "this is the same error message"}],
             )
@@ -372,6 +399,7 @@ def test_search_query_with_multiple_search_items(self):
         with freeze_time("2022-01-10 12:11:00"):
             self.create_events_and_issue(
                 issue_id="01936e81-b0ce-7b56-8497-791e505b0d0c",
+                fingerprint="fingerprint_DatabaseNotFoundX",
                 distinct_ids=[self.distinct_id_one],
                 exception_list=[
                     {
@@ -384,6 +412,7 @@ def test_search_query_with_multiple_search_items(self):
 
             self.create_events_and_issue(
                 issue_id="01936e81-f5ce-79b1-99f1-f0e9675fcfef",
+                fingerprint="fingerprint_DatabaseNotFoundY",
                 distinct_ids=[self.distinct_id_two],
                 exception_list=[
                     {
@@ -420,7 +449,7 @@ def test_only_returns_exception_events(self):
                 distinct_id=self.distinct_id_one,
                 event="$pageview",
                 team=self.team,
-                properties={"$exception_issue_id": self.issue_one},
+                properties={"$exception_issue_id": self.issue_id_one},
             )
         flush_persons_and_events()
 
@@ -470,7 +499,7 @@ def test_ordering(self):
         )
 
         results = self._calculate(runner)["results"]
-        self.assertEqual([r["id"] for r in results], [self.issue_three, self.issue_two, self.issue_one])
+        self.assertEqual([r["id"] for r in results], [self.issue_id_three, self.issue_id_two, self.issue_id_one])
 
         runner = ErrorTrackingQueryRunner(
             team=self.team,
@@ -478,88 +507,72 @@ def test_ordering(self):
         )
 
         results = self._calculate(runner)["results"]
-        self.assertEqual([r["id"] for r in results], [self.issue_one, self.issue_two, self.issue_three])
-
-    # def test_merges_and_defaults_groups(self):
-    #     ErrorTrackingGroup.objects.create(
-    #         team=self.team,
-    #         fingerprint=["SyntaxError"],
-    #         merged_fingerprints=[["custom_fingerprint"]],
-    #         assignee=self.user,
-    #     )
-
-    #     runner = ErrorTrackingQueryRunner(
-    #         team=self.team,
-    #         query=ErrorTrackingQuery(
-    #             kind="ErrorTrackingQuery", fingerprint=None, dateRange=DateRange(), order="occurrences"
-    #         ),
-    #     )
-
-    #     results = self._calculate(runner)["results"]
-    #     self.assertEqual(
-    #         results,
-    #         [
-    #             {
-    #                 "assignee": self.user.id,
-    #                 "description": "this is the same error message",
-    #                 "exception_type": "SyntaxError",
-    #                 "fingerprint": ["SyntaxError"],
-    #                 "first_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
-    #                 "last_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
-    #                 "merged_fingerprints": [["custom_fingerprint"]],
-    #                 # count is (2 x SyntaxError) + (1 x custom_fingerprint)
-    #                 "occurrences": 3,
-    #                 "sessions": 1,
-    #                 "users": 2,
-    #                 "volume": None,
-    #                 "status": ErrorTrackingGroup.Status.ACTIVE,
-    #             },
-    #             {
-    #                 "assignee": None,
-    #                 "description": None,
-    #                 "exception_type": "TypeError",
-    #                 "fingerprint": ["TypeError"],
-    #                 "first_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
-    #                 "last_seen": datetime(2020, 1, 10, 12, 11, tzinfo=ZoneInfo("UTC")),
-    #                 "merged_fingerprints": [],
-    #                 "occurrences": 1,
-    #                 "sessions": 1,
-    #                 "users": 1,
-    #                 "volume": None,
-    #                 "status": ErrorTrackingGroup.Status.ACTIVE,
-    #             },
-    #         ],
-    #     )
-
-    # @snapshot_clickhouse_queries
-    # def test_assignee_groups(self):
-    #     ErrorTrackingGroup.objects.create(
-    #         team=self.team,
-    #         fingerprint=["SyntaxError"],
-    #         assignee=self.user,
-    #     )
-    #     ErrorTrackingGroup.objects.create(
-    #         team=self.team,
-    #         fingerprint=["custom_fingerprint"],
-    #         assignee=self.user,
-    #     )
-    #     ErrorTrackingGroup.objects.create(
-    #         team=self.team,
-    #         fingerprint=["TypeError"],
-    #     )
-
-    #     runner = ErrorTrackingQueryRunner(
-    #         team=self.team,
-    #         query=ErrorTrackingQuery(
-    #             kind="ErrorTrackingQuery",
-    #             dateRange=DateRange(),
-    #             assignee=self.user.pk,
-    #         ),
-    #     )
-
-    #     results = self._calculate(runner)["results"]
-
-    #     self.assertEqual(sorted([x["fingerprint"] for x in results]), [["SyntaxError"], ["custom_fingerprint"]])
+        self.assertEqual([r["id"] for r in results], [self.issue_id_one, self.issue_id_two, self.issue_id_three])
+
+    def test_overrides_aggregation(self):
+        self.override_fingerprint(self.issue_three_fingerprint, self.issue_id_one)
+
+        runner = ErrorTrackingQueryRunner(
+            team=self.team,
+            query=ErrorTrackingQuery(kind="ErrorTrackingQuery", dateRange=DateRange(), orderBy="occurrences"),
+        )
+
+        results = self._calculate(runner)["results"]
+        self.assertEqual(
+            results,
+            [
+                {
+                    "id": self.issue_id_one,
+                    "name": None,
+                    "description": None,
+                    "assignee": None,
+                    "volume": None,
+                    "status": ErrorTrackingIssue.Status.ACTIVE,
+                    "first_seen": datetime(2020, 1, 10, 9, 11, tzinfo=ZoneInfo("UTC")),
+                    "last_seen": datetime(2020, 1, 10, 11, 11, tzinfo=ZoneInfo("UTC")),
+                    # count is (2 x issue_one) + (1 x issue_three)
+                    "occurrences": 3,
+                    "sessions": 1,
+                    "users": 2,
+                },
+                {
+                    "id": self.issue_id_two,
+                    "name": None,
+                    "description": None,
+                    "assignee": None,
+                    "volume": None,
+                    "status": ErrorTrackingIssue.Status.ACTIVE,
+                    "first_seen": datetime(2020, 1, 10, 10, 11, tzinfo=ZoneInfo("UTC")),
+                    "last_seen": datetime(2020, 1, 10, 10, 11, tzinfo=ZoneInfo("UTC")),
+                    "occurrences": 1,
+                    "sessions": 1,
+                    "users": 1,
+                },
+            ],
+        )
+
+    @snapshot_clickhouse_queries
+    def test_assignee_groups(self):
+        issue_id = "e9ac529f-ac1c-4a96-bd3a-107034368d64"
+        self.create_events_and_issue(
+            issue_id=issue_id,
+            fingerprint="assigned_issue_fingerprint",
+            distinct_ids=[self.distinct_id_one],
+        )
+        flush_persons_and_events()
+        ErrorTrackingIssueAssignment.objects.create(issue_id=issue_id, user=self.user)
+
+        runner = ErrorTrackingQueryRunner(
+            team=self.team,
+            query=ErrorTrackingQuery(
+                kind="ErrorTrackingQuery",
+                dateRange=DateRange(),
+                assignee=self.user.pk,
+            ),
+        )
+
+        results = self._calculate(runner)["results"]
+        self.assertEqual([x["id"] for x in results], [issue_id])
 
 
 class TestSearchTokenizer(TestCase):
diff --git a/posthog/hogql_queries/utils/query_compare_to_date_range.py b/posthog/hogql_queries/utils/query_compare_to_date_range.py
index b05d977640e69..b72503e39d03a 100644
--- a/posthog/hogql_queries/utils/query_compare_to_date_range.py
+++ b/posthog/hogql_queries/utils/query_compare_to_date_range.py
@@ -3,7 +3,7 @@
 
 from posthog.hogql_queries.utils.query_date_range import QueryDateRange
 from posthog.models.team import Team
-from posthog.schema import DateRange, IntervalType, InsightDateRange
+from posthog.schema import DateRange, IntervalType
 from posthog.utils import (
     relative_date_parse,
 )
@@ -13,14 +13,14 @@ class QueryCompareToDateRange(QueryDateRange):
     """Moves the start of a date range back by the compare_to interval and sets the end to have the same delta as the original"""
 
     _team: Team
-    _date_range: Optional[InsightDateRange | DateRange]
+    _date_range: Optional[DateRange]
     _interval: Optional[IntervalType]
     _now_without_timezone: datetime
     _compare_to: str
 
     def __init__(
         self,
-        date_range: Optional[InsightDateRange | DateRange],
+        date_range: Optional[DateRange],
         team: Team,
         interval: Optional[IntervalType],
         now: datetime,
diff --git a/posthog/hogql_queries/utils/query_date_range.py b/posthog/hogql_queries/utils/query_date_range.py
index 46fa611b6fee1..fbceab9f9b845 100644
--- a/posthog/hogql_queries/utils/query_date_range.py
+++ b/posthog/hogql_queries/utils/query_date_range.py
@@ -9,7 +9,7 @@
 from posthog.hogql.parser import ast
 from posthog.models.team import Team, WeekStartDay
 from posthog.queries.util import get_earliest_timestamp, get_trunc_func_ch
-from posthog.schema import DateRange, InsightDateRange, IntervalType
+from posthog.schema import DateRange, IntervalType
 from posthog.utils import (
     DEFAULT_DATE_FROM_DAYS,
     relative_date_parse,
@@ -24,13 +24,13 @@ class QueryDateRange:
     """Translation of the raw `date_from` and `date_to` filter values to datetimes."""
 
     _team: Team
-    _date_range: Optional[InsightDateRange | DateRange]
+    _date_range: Optional[DateRange]
     _interval: Optional[IntervalType]
     _now_without_timezone: datetime
 
     def __init__(
         self,
-        date_range: Optional[InsightDateRange | DateRange],
+        date_range: Optional[DateRange],
         team: Team,
         interval: Optional[IntervalType],
         now: datetime,
@@ -285,7 +285,7 @@ def to_placeholders(self) -> dict[str, ast.Expr]:
 class QueryDateRangeWithIntervals(QueryDateRange):
     def __init__(
         self,
-        date_range: Optional[InsightDateRange],
+        date_range: Optional[DateRange],
         total_intervals: int,
         team: Team,
         interval: Optional[IntervalType],
diff --git a/posthog/hogql_queries/utils/query_previous_period_date_range.py b/posthog/hogql_queries/utils/query_previous_period_date_range.py
index e4aa8b9e1368a..c6dca63dc7d95 100644
--- a/posthog/hogql_queries/utils/query_previous_period_date_range.py
+++ b/posthog/hogql_queries/utils/query_previous_period_date_range.py
@@ -3,7 +3,7 @@
 
 from posthog.hogql_queries.utils.query_date_range import QueryDateRange
 from posthog.models.team import Team
-from posthog.schema import InsightDateRange, IntervalType
+from posthog.schema import DateRange, IntervalType
 from posthog.utils import (
     get_compare_period_dates,
     relative_date_parse_with_delta_mapping,
@@ -15,13 +15,13 @@ class QueryPreviousPeriodDateRange(QueryDateRange):
     """Translation of the raw `date_from` and `date_to` filter values to datetimes."""
 
     _team: Team
-    _date_range: Optional[InsightDateRange]
+    _date_range: Optional[DateRange]
     _interval: Optional[IntervalType]
     _now_without_timezone: datetime
 
     def __init__(
         self,
-        date_range: Optional[InsightDateRange],
+        date_range: Optional[DateRange],
         team: Team,
         interval: Optional[IntervalType],
         now: datetime,
diff --git a/posthog/hogql_queries/utils/test/test_query_date_range.py b/posthog/hogql_queries/utils/test/test_query_date_range.py
index c87c29ebcbd72..4c260fdd4f913 100644
--- a/posthog/hogql_queries/utils/test/test_query_date_range.py
+++ b/posthog/hogql_queries/utils/test/test_query_date_range.py
@@ -5,21 +5,21 @@
 from posthog.hogql import ast
 from posthog.hogql_queries.utils.query_date_range import QueryDateRange, QueryDateRangeWithIntervals
 from posthog.models.team import WeekStartDay
-from posthog.schema import InsightDateRange, IntervalType
+from posthog.schema import DateRange, IntervalType
 from posthog.test.base import APIBaseTest
 
 
 class TestQueryDateRange(APIBaseTest):
     def test_parsed_date(self):
         now = parser.isoparse("2021-08-25T00:00:00.000Z")
-        date_range = InsightDateRange(date_from="-48h")
+        date_range = DateRange(date_from="-48h")
         query_date_range = QueryDateRange(team=self.team, date_range=date_range, interval=IntervalType.DAY, now=now)
         self.assertEqual(query_date_range.date_from(), parser.isoparse("2021-08-23T00:00:00Z"))
         self.assertEqual(query_date_range.date_to(), parser.isoparse("2021-08-25T23:59:59.999999Z"))
 
     def test_parsed_date_hour(self):
         now = parser.isoparse("2021-08-25T00:00:00.000Z")
-        date_range = InsightDateRange(date_from="-48h")
+        date_range = DateRange(date_from="-48h")
         query_date_range = QueryDateRange(team=self.team, date_range=date_range, interval=IntervalType.HOUR, now=now)
 
         self.assertEqual(query_date_range.date_from(), parser.isoparse("2021-08-23T00:00:00Z"))
@@ -29,7 +29,7 @@ def test_parsed_date_hour(self):
 
     def test_parsed_date_middle_of_hour(self):
         now = parser.isoparse("2021-08-25T00:00:00.000Z")
-        date_range = InsightDateRange(date_from="2021-08-23 05:00:00", date_to="2021-08-26 07:00:00")
+        date_range = DateRange(date_from="2021-08-23 05:00:00", date_to="2021-08-26 07:00:00")
         query_date_range = QueryDateRange(team=self.team, date_range=date_range, interval=IntervalType.HOUR, now=now)
 
         self.assertEqual(query_date_range.date_from(), parser.isoparse("2021-08-23 05:00:00Z"))
@@ -39,7 +39,7 @@ def test_parsed_date_middle_of_hour(self):
 
     def test_parsed_date_week(self):
         now = parser.isoparse("2021-08-25T00:00:00.000Z")
-        date_range = InsightDateRange(date_from="-7d")
+        date_range = DateRange(date_from="-7d")
         query_date_range = QueryDateRange(team=self.team, date_range=date_range, interval=IntervalType.WEEK, now=now)
 
         self.assertEqual(query_date_range.date_from(), parser.isoparse("2021-08-18 00:00:00Z"))
@@ -49,13 +49,13 @@ def test_all_values(self):
         now = parser.isoparse("2021-08-25T00:00:00.000Z")
         self.assertEqual(
             QueryDateRange(
-                team=self.team, date_range=InsightDateRange(date_from="-20h"), interval=IntervalType.DAY, now=now
+                team=self.team, date_range=DateRange(date_from="-20h"), interval=IntervalType.DAY, now=now
             ).all_values(),
             [parser.isoparse("2021-08-24T00:00:00Z"), parser.isoparse("2021-08-25T00:00:00Z")],
         )
         self.assertEqual(
             QueryDateRange(
-                team=self.team, date_range=InsightDateRange(date_from="-20d"), interval=IntervalType.WEEK, now=now
+                team=self.team, date_range=DateRange(date_from="-20d"), interval=IntervalType.WEEK, now=now
             ).all_values(),
             [
                 parser.isoparse("2021-08-01T00:00:00Z"),
@@ -67,7 +67,7 @@ def test_all_values(self):
         self.team.week_start_day = WeekStartDay.MONDAY
         self.assertEqual(
             QueryDateRange(
-                team=self.team, date_range=InsightDateRange(date_from="-20d"), interval=IntervalType.WEEK, now=now
+                team=self.team, date_range=DateRange(date_from="-20d"), interval=IntervalType.WEEK, now=now
             ).all_values(),
             [
                 parser.isoparse("2021-08-02T00:00:00Z"),
@@ -78,13 +78,13 @@ def test_all_values(self):
         )
         self.assertEqual(
             QueryDateRange(
-                team=self.team, date_range=InsightDateRange(date_from="-50d"), interval=IntervalType.MONTH, now=now
+                team=self.team, date_range=DateRange(date_from="-50d"), interval=IntervalType.MONTH, now=now
             ).all_values(),
             [parser.isoparse("2021-07-01T00:00:00Z"), parser.isoparse("2021-08-01T00:00:00Z")],
         )
         self.assertEqual(
             QueryDateRange(
-                team=self.team, date_range=InsightDateRange(date_from="-3h"), interval=IntervalType.HOUR, now=now
+                team=self.team, date_range=DateRange(date_from="-3h"), interval=IntervalType.HOUR, now=now
             ).all_values(),
             [
                 parser.isoparse("2021-08-24T21:00:00Z"),
@@ -96,7 +96,7 @@ def test_all_values(self):
 
     def test_date_to_explicit(self):
         now = parser.isoparse("2021-08-25T00:00:00.000Z")
-        date_range = InsightDateRange(
+        date_range = DateRange(
             date_from="2021-02-25T12:25:23.000Z", date_to="2021-04-25T10:59:23.000Z", explicitDate=True
         )
         query_date_range = QueryDateRange(team=self.team, date_range=date_range, interval=IntervalType.DAY, now=now)
@@ -106,7 +106,7 @@ def test_date_to_explicit(self):
 
     def test_yesterday(self):
         now = parser.isoparse("2021-08-25T00:00:00.000Z")
-        date_range = InsightDateRange(date_from="-1dStart", date_to="-1dEnd", explicitDate=False)
+        date_range = DateRange(date_from="-1dStart", date_to="-1dEnd", explicitDate=False)
 
         query_date_range = QueryDateRange(team=self.team, date_range=date_range, interval=IntervalType.HOUR, now=now)
 
diff --git a/posthog/hogql_queries/web_analytics/external_clicks.py b/posthog/hogql_queries/web_analytics/external_clicks.py
index 005393b71793a..35f3376d6c4f6 100644
--- a/posthog/hogql_queries/web_analytics/external_clicks.py
+++ b/posthog/hogql_queries/web_analytics/external_clicks.py
@@ -43,36 +43,38 @@ def to_query(self) -> ast.SelectQuery:
                 """
 SELECT
     url AS "context.columns.url",
-    uniq(filtered_person_id) AS "context.columns.visitors",
-    sum(filtered_click_count) AS "context.columns.clicks"
+    tuple(uniqIf(filtered_person_id, {current_period}), uniqIf(filtered_person_id, {previous_period})) AS "context.columns.visitors",
+    tuple(sumIf(filtered_click_count, {current_period}), sumIf(filtered_click_count, {previous_period})) AS "context.columns.clicks"
 FROM (
     SELECT
         any(person_id) AS filtered_person_id,
         count() AS filtered_click_count,
-        {url_expr} AS url
+        {url_expr} AS url,
+        MIN(session.$start_timestamp) AS start_timestamp
     FROM events
     WHERE and(
-        timestamp >= {date_from},
-        timestamp < {date_to},
         events.event == '$autocapture',
         events.properties.$event_type == 'click',
         url IS NOT NULL,
         url != '',
         cutToFirstSignificantSubdomain(properties.`$external_click_url`) != cutToFirstSignificantSubdomain(properties.`$host`),
-        {all_properties}
+        {inside_periods},
+        {all_properties},
     )
     GROUP BY events.`$session_id`, url
 )
 GROUP BY "context.columns.url"
 ORDER BY "context.columns.visitors" DESC,
+"context.columns.clicks" DESC,
 "context.columns.url" ASC
 """,
                 timings=self.timings,
                 placeholders={
                     "url_expr": url_expr,
                     "all_properties": self._all_properties(),
-                    "date_from": self._date_from(),
-                    "date_to": self._date_to(),
+                    "current_period": self._current_period_expression(),
+                    "previous_period": self._previous_period_expression(),
+                    "inside_periods": self._periods_expression(),
                 },
             )
         assert isinstance(query, ast.SelectQuery)
@@ -82,12 +84,6 @@ def _all_properties(self) -> ast.Expr:
         properties = self.query.properties + self._test_account_filters
         return property_to_expr(properties, team=self.team)
 
-    def _date_to(self) -> ast.Expr:
-        return self.query_date_range.date_to_as_hogql()
-
-    def _date_from(self) -> ast.Expr:
-        return self.query_date_range.date_from_as_hogql()
-
     def calculate(self):
         query = self.to_query()
         response = self.paginator.execute_hogql_query(
@@ -104,8 +100,14 @@ def calculate(self):
         results_mapped = map_columns(
             results,
             {
-                1: self._unsample,  # views
-                2: self._unsample,  # visitors
+                1: lambda tuple, row: (  # Visitors (tuple)
+                    self._unsample(tuple[0], row),
+                    self._unsample(tuple[1], row),
+                ),
+                2: lambda tuple, row: (  # Clicks (tuple)
+                    self._unsample(tuple[0], row),
+                    self._unsample(tuple[1], row),
+                ),
             },
         )
 
diff --git a/posthog/hogql_queries/web_analytics/stats_table.py b/posthog/hogql_queries/web_analytics/stats_table.py
index 1633c4389879d..7135934bc6625 100644
--- a/posthog/hogql_queries/web_analytics/stats_table.py
+++ b/posthog/hogql_queries/web_analytics/stats_table.py
@@ -41,7 +41,9 @@ def __init__(self, *args, **kwargs):
 
     def to_query(self) -> ast.SelectQuery:
         if self.query.breakdownBy == WebStatsBreakdown.PAGE:
-            if self.query.includeScrollDepth and self.query.includeBounceRate:
+            if self.query.conversionGoal:
+                return self.to_main_query(self._counts_breakdown_value())
+            elif self.query.includeScrollDepth and self.query.includeBounceRate:
                 return self.to_path_scroll_bounce_query()
             elif self.query.includeBounceRate:
                 return self.to_path_bounce_query()
@@ -50,196 +52,80 @@ def to_query(self) -> ast.SelectQuery:
             if self.query.includeBounceRate:
                 return self.to_entry_bounce_query()
 
-        if self._has_session_properties():
-            return self._to_main_query_with_session_properties()
+        return self.to_main_query(self._counts_breakdown_value())
 
-        return self.to_main_query()
-
-    def to_main_query(self) -> ast.SelectQuery:
+    def to_main_query(self, breakdown) -> ast.SelectQuery:
         with self.timings.measure("stats_table_query"):
-            query = parse_select(
-                """
-WITH
-    start_timestamp >= {date_from} AND start_timestamp < {date_to} AS current_period_segment,
-    start_timestamp >= {date_from_previous_period} AND start_timestamp < {date_from} AS previous_period_segment
-SELECT
-    {processed_breakdown_value} AS "context.columns.breakdown_value",
-    tuple(
-        uniqIf(filtered_person_id, current_period_segment),
-        uniqIf(filtered_person_id, previous_period_segment)
-    ) AS "context.columns.visitors",
-    tuple(
-        sumIf(filtered_pageview_count, current_period_segment),
-        sumIf(filtered_pageview_count, previous_period_segment)
-    ) AS "context.columns.views"
-FROM (
-    SELECT
-        any(person_id) AS filtered_person_id,
-        count() AS filtered_pageview_count,
-        {breakdown_value} AS breakdown_value,
-        min(session.$start_timestamp) as start_timestamp
-    FROM events
-    WHERE and(
-        timestamp >= {date_from_previous_period},
-        timestamp < {date_to},
-        events.event == '$pageview',
-        {all_properties},
-        {where_breakdown}
-    )
-    GROUP BY events.`$session_id`, breakdown_value
-)
-GROUP BY "context.columns.breakdown_value"
-ORDER BY "context.columns.visitors" DESC,
-"context.columns.views" DESC,
-"context.columns.breakdown_value" ASC
-""",
-                timings=self.timings,
-                placeholders={
-                    "breakdown_value": self._counts_breakdown_value(),
-                    "processed_breakdown_value": self._processed_breakdown_value(),
-                    "where_breakdown": self.where_breakdown(),
-                    "all_properties": self._all_properties(),
-                    "date_from_previous_period": self._date_from_previous_period(),
-                    "date_from": self._date_from(),
-                    "date_to": self._date_to(),
-                },
-            )
-
-        assert isinstance(query, ast.SelectQuery)
-
-        if self._include_extra_aggregation_value():
-            query.select.append(self._extra_aggregation_value())
-
-        return query
+            # Base selects, always returns the breakdown value, and the total number of visitors
+            selects = [
+                ast.Alias(alias="context.columns.breakdown_value", expr=self._processed_breakdown_value()),
+                self._period_comparison_tuple("filtered_person_id", "context.columns.visitors", "uniq"),
+            ]
+
+            if self.query.conversionGoal is not None:
+                selects.extend(
+                    [
+                        self._period_comparison_tuple("conversion_count", "context.columns.total_conversions", "sum"),
+                        self._period_comparison_tuple(
+                            "conversion_person_id", "context.columns.unique_conversions", "uniq"
+                        ),
+                        ast.Alias(
+                            alias="context.columns.conversion_rate",
+                            expr=ast.Tuple(
+                                exprs=[
+                                    parse_expr(
+                                        "if(`context.columns.visitors`.1 = 0, NULL, `context.columns.unique_conversions`.1 / `context.columns.visitors`.1)"
+                                    ),
+                                    parse_expr(
+                                        "if(`context.columns.visitors`.2 = 0, NULL, `context.columns.unique_conversions`.2 / `context.columns.visitors`.2)"
+                                    ),
+                                ]
+                            ),
+                        ),
+                    ]
+                )
+            else:
+                selects.append(
+                    self._period_comparison_tuple("filtered_pageview_count", "context.columns.views", "sum"),
+                )
 
-    def _to_main_query_with_session_properties(self) -> ast.SelectQuery:
-        with self.timings.measure("stats_table_query"):
-            query = parse_select(
-                """
-WITH
-    start_timestamp >= {date_from} AND start_timestamp < {date_to} AS current_period_segment,
-    start_timestamp >= {date_from_previous_period} AND start_timestamp < {date_from} AS previous_period_segment
-SELECT
-    {processed_breakdown_value} AS "context.columns.breakdown_value",
-    tuple(
-        uniqIf(filtered_person_id, current_period_segment),
-        uniqIf(filtered_person_id, previous_period_segment)
-    ) AS "context.columns.visitors",
-    tuple(
-        sumIf(filtered_pageview_count, current_period_segment),
-        sumIf(filtered_pageview_count, previous_period_segment)
-    )  AS "context.columns.views"
-FROM (
-    SELECT
-        any(person_id) AS filtered_person_id,
-        count() AS filtered_pageview_count,
-        {breakdown_value} AS breakdown_value,
-        session.session_id AS session_id,
-        min(session.$start_timestamp) as start_timestamp
-    FROM events
-    WHERE and(
-        timestamp >= {date_from_previous_period},
-        timestamp < {date_to},
-        events.event == '$pageview',
-        {event_properties},
-        {session_properties},
-        {where_breakdown}
-    )
-    GROUP BY session_id, breakdown_value
-)
-GROUP BY "context.columns.breakdown_value"
-ORDER BY "context.columns.visitors" DESC,
-"context.columns.views" DESC,
-"context.columns.breakdown_value" ASC
-""",
-                timings=self.timings,
-                placeholders={
-                    "breakdown_value": self._counts_breakdown_value(),
-                    "processed_breakdown_value": self._processed_breakdown_value(),
-                    "where_breakdown": self.where_breakdown(),
-                    "event_properties": self._event_properties(),
-                    "session_properties": self._session_properties(),
-                    "date_from_previous_period": self._date_from_previous_period(),
-                    "date_from": self._date_from(),
-                    "date_to": self._date_to(),
-                },
+                if self._include_extra_aggregation_value():
+                    selects.append(self._extra_aggregation_value())
+
+            query = ast.SelectQuery(
+                select=selects,
+                select_from=ast.JoinExpr(table=self._main_inner_query(breakdown)),
+                group_by=[ast.Field(chain=["context.columns.breakdown_value"])],
+                order_by=[
+                    ast.OrderExpr(expr=ast.Field(chain=["context.columns.visitors"]), order="DESC"),
+                    ast.OrderExpr(
+                        expr=ast.Field(
+                            chain=[
+                                "context.columns.views"
+                                if self.query.conversionGoal is None
+                                else "context.columns.total_conversions"
+                            ]
+                        ),
+                        order="DESC",
+                    ),
+                    ast.OrderExpr(expr=ast.Field(chain=["context.columns.breakdown_value"]), order="ASC"),
+                ],
             )
-        assert isinstance(query, ast.SelectQuery)
-
-        if self.query.breakdownBy == WebStatsBreakdown.LANGUAGE:
-            query.select.append(self._extra_aggregation_value())
 
         return query
 
     def to_entry_bounce_query(self) -> ast.SelectQuery:
-        with self.timings.measure("stats_table_query"):
-            query = parse_select(
-                """
-WITH
-    start_timestamp >= {date_from} AND start_timestamp < {date_to} AS current_period_segment,
-    start_timestamp >= {date_from_previous_period} AND start_timestamp < {date_from} AS previous_period_segment
-SELECT
-    breakdown_value AS "context.columns.breakdown_value",
-    tuple(
-        uniqIf(filtered_person_id, current_period_segment),
-        uniqIf(filtered_person_id, previous_period_segment)
-    ) AS "context.columns.visitors",
-    tuple(
-        sumIf(filtered_pageview_count, current_period_segment),
-        sumIf(filtered_pageview_count, previous_period_segment)
-    ) AS "context.columns.views",
-    tuple(
-        avgIf(is_bounce, current_period_segment),
-        avgIf(is_bounce, previous_period_segment)
-    ) AS "context.columns.bounce_rate",
-FROM (
-    SELECT
-        {bounce_breakdown} AS breakdown_value,
-        any(person_id) AS filtered_person_id,
-        count() AS filtered_pageview_count,
-        any(session.$is_bounce) AS is_bounce,
-        session.session_id AS session_id,
-        min(session.$start_timestamp) as start_timestamp
-    FROM events
-    WHERE and(
-        timestamp >= {date_from_previous_period},
-        timestamp < {date_to},
-        events.event == '$pageview',
-        {event_properties},
-        {session_properties},
-        {where_breakdown}
-    )
-    GROUP BY session_id, breakdown_value
-)
-GROUP BY "context.columns.breakdown_value"
-ORDER BY "context.columns.visitors" DESC,
-"context.columns.views" DESC,
-"context.columns.breakdown_value" ASC
-""",
-                timings=self.timings,
-                placeholders={
-                    "bounce_breakdown": self._bounce_entry_pathname_breakdown(),
-                    "where_breakdown": self.where_breakdown(),
-                    "session_properties": self._session_properties(),
-                    "event_properties": self._event_properties(),
-                    "date_from_previous_period": self._date_from_previous_period(),
-                    "date_from": self._date_from(),
-                    "date_to": self._date_to(),
-                },
-            )
-        assert isinstance(query, ast.SelectQuery)
+        query = self.to_main_query(self._bounce_entry_pathname_breakdown())
+
+        if self.query.conversionGoal is None:
+            query.select.append(self._period_comparison_tuple("is_bounce", "context.columns.bounce_rate", "avg"))
+
         return query
 
     def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
-        if self.query.breakdownBy != WebStatsBreakdown.PAGE:
-            raise NotImplementedError("Scroll depth is only supported for page breakdowns")
-
         with self.timings.measure("stats_table_bounce_query"):
             query = parse_select(
                 """
-WITH
-    start_timestamp >= {date_from} AND start_timestamp < {date_to} AS current_period_segment,
-    start_timestamp >= {date_from_previous_period} AND start_timestamp < {date_from} AS previous_period_segment
 SELECT
     counts.breakdown_value AS "context.columns.breakdown_value",
     tuple(counts.visitors, counts.previous_visitors) AS "context.columns.visitors",
@@ -250,10 +136,10 @@ def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
 FROM (
     SELECT
         breakdown_value,
-        uniqIf(filtered_person_id, current_period_segment) AS visitors,
-        uniqIf(filtered_person_id, previous_period_segment) AS previous_visitors,
-        sumIf(filtered_pageview_count, current_period_segment) AS views,
-        sumIf(filtered_pageview_count, previous_period_segment) AS previous_views
+        uniqIf(filtered_person_id, {current_period}) AS visitors,
+        uniqIf(filtered_person_id, {previous_period}) AS previous_visitors,
+        sumIf(filtered_pageview_count, {current_period}) AS views,
+        sumIf(filtered_pageview_count, {previous_period}) AS previous_views
     FROM (
         SELECT
             any(person_id) AS filtered_person_id,
@@ -263,12 +149,11 @@ def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
             min(session.$start_timestamp ) AS start_timestamp
         FROM events
         WHERE and(
-            timestamp >= {date_from_previous_period},
-            timestamp < {date_to},
             events.event == '$pageview',
+            breakdown_value IS NOT NULL,
+            {inside_periods},
             {event_properties},
             {session_properties},
-            breakdown_value IS NOT NULL
         )
         GROUP BY session_id, breakdown_value
     )
@@ -277,8 +162,8 @@ def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
 LEFT JOIN (
     SELECT
         breakdown_value,
-        avgIf(is_bounce, current_period_segment) AS bounce_rate,
-        avgIf(is_bounce, previous_period_segment) AS previous_bounce_rate
+        avgIf(is_bounce, {current_period}) AS bounce_rate,
+        avgIf(is_bounce, {previous_period}) AS previous_bounce_rate
     FROM (
         SELECT
             {bounce_breakdown_value} AS breakdown_value, -- use $entry_pathname to find the bounce rate for sessions that started on this pathname
@@ -287,12 +172,11 @@ def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
             min(session.$start_timestamp) as start_timestamp
         FROM events
         WHERE and(
-            timestamp >= {date_from_previous_period},
-            timestamp < {date_to},
             events.event == '$pageview',
+            breakdown_value IS NOT NULL,
+            {inside_periods},
             {event_properties},
             {session_properties},
-            breakdown_value IS NOT NULL
         )
         GROUP BY session_id, breakdown_value
     )
@@ -302,10 +186,10 @@ def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
 LEFT JOIN (
     SELECT
         breakdown_value,
-        avgMergeIf(average_scroll_percentage_state, current_period_segment) AS average_scroll_percentage,
-        avgMergeIf(average_scroll_percentage_state, previous_period_segment) AS previous_average_scroll_percentage,
-        avgMergeIf(scroll_gt80_percentage_state, current_period_segment) AS scroll_gt80_percentage,
-        avgMergeIf(scroll_gt80_percentage_state, previous_period_segment) AS previous_scroll_gt80_percentage
+        avgMergeIf(average_scroll_percentage_state, {current_period}) AS average_scroll_percentage,
+        avgMergeIf(average_scroll_percentage_state, {previous_period}) AS previous_average_scroll_percentage,
+        avgMergeIf(scroll_gt80_percentage_state, {current_period}) AS scroll_gt80_percentage,
+        avgMergeIf(scroll_gt80_percentage_state, {previous_period}) AS previous_scroll_gt80_percentage
     FROM (
         SELECT
             {scroll_breakdown_value} AS breakdown_value, -- use $prev_pageview_pathname to find the scroll depth when leaving this pathname
@@ -320,12 +204,11 @@ def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
             min(session.$start_timestamp) AS start_timestamp
         FROM events
         WHERE and(
-            timestamp >= {date_from_previous_period},
-            timestamp < {date_to},
             or(events.event == '$pageview', events.event == '$pageleave'),
+            breakdown_value IS NOT NULL,
+            {inside_periods},
             {event_properties_for_scroll},
             {session_properties},
-            breakdown_value IS NOT NULL
         )
         GROUP BY session_id, breakdown_value
     )
@@ -341,12 +224,12 @@ def to_path_scroll_bounce_query(self) -> ast.SelectQuery:
                     "session_properties": self._session_properties(),
                     "event_properties": self._event_properties(),
                     "event_properties_for_scroll": self._event_properties_for_scroll(),
-                    "date_from_previous_period": self._date_from_previous_period(),
-                    "date_from": self._date_from(),
-                    "date_to": self._date_to(),
                     "breakdown_value": self._counts_breakdown_value(),
                     "scroll_breakdown_value": self._scroll_prev_pathname_breakdown(),
                     "bounce_breakdown_value": self._bounce_entry_pathname_breakdown(),
+                    "current_period": self._current_period_expression(),
+                    "previous_period": self._previous_period_expression(),
+                    "inside_periods": self._periods_expression(),
                 },
             )
         assert isinstance(query, ast.SelectQuery)
@@ -359,9 +242,6 @@ def to_path_bounce_query(self) -> ast.SelectQuery:
         with self.timings.measure("stats_table_scroll_query"):
             query = parse_select(
                 """
-WITH
-    start_timestamp >= {date_from} AND start_timestamp < {date_to} AS current_period_segment,
-    start_timestamp >= {date_from_previous_period} AND start_timestamp < {date_from} AS previous_period_segment
 SELECT
     counts.breakdown_value AS "context.columns.breakdown_value",
     tuple(counts.visitors, counts.previous_visitors) AS "context.columns.visitors",
@@ -370,10 +250,10 @@ def to_path_bounce_query(self) -> ast.SelectQuery:
 FROM (
     SELECT
         breakdown_value,
-        uniqIf(filtered_person_id, current_period_segment) AS visitors,
-        uniqIf(filtered_person_id, previous_period_segment) AS previous_visitors,
-        sumIf(filtered_pageview_count, current_period_segment) AS views,
-        sumIf(filtered_pageview_count, previous_period_segment) AS previous_views
+        uniqIf(filtered_person_id, {current_period}) AS visitors,
+        uniqIf(filtered_person_id, {previous_period}) AS previous_visitors,
+        sumIf(filtered_pageview_count, {current_period}) AS views,
+        sumIf(filtered_pageview_count, {previous_period}) AS previous_views
     FROM (
         SELECT
             any(person_id) AS filtered_person_id,
@@ -383,12 +263,11 @@ def to_path_bounce_query(self) -> ast.SelectQuery:
             min(session.$start_timestamp) AS start_timestamp
         FROM events
         WHERE and(
-            timestamp >= {date_from_previous_period},
-            timestamp < {date_to},
             events.event == '$pageview',
+            {inside_periods},
             {event_properties},
             {session_properties},
-            {where_breakdown}
+            {where_breakdown},
         )
         GROUP BY session_id, breakdown_value
     )
@@ -397,8 +276,8 @@ def to_path_bounce_query(self) -> ast.SelectQuery:
 LEFT JOIN (
     SELECT
         breakdown_value,
-        avgIf(is_bounce, current_period_segment) AS bounce_rate,
-        avgIf(is_bounce, previous_period_segment) AS previous_bounce_rate
+        avgIf(is_bounce, {current_period}) AS bounce_rate,
+        avgIf(is_bounce, {previous_period}) AS previous_bounce_rate
     FROM (
         SELECT
             {bounce_breakdown_value} AS breakdown_value, -- use $entry_pathname to find the bounce rate for sessions that started on this pathname
@@ -407,12 +286,11 @@ def to_path_bounce_query(self) -> ast.SelectQuery:
             min(session.$start_timestamp) AS start_timestamp
         FROM events
         WHERE and(
-            timestamp >= {date_from_previous_period},
-            timestamp < {date_to},
             events.event == '$pageview',
+            breakdown_value IS NOT NULL,
+            {inside_periods},
             {event_properties},
             {session_properties},
-            breakdown_value IS NOT NULL
         )
         GROUP BY session_id, breakdown_value
     )
@@ -429,15 +307,80 @@ def to_path_bounce_query(self) -> ast.SelectQuery:
                     "where_breakdown": self.where_breakdown(),
                     "session_properties": self._session_properties(),
                     "event_properties": self._event_properties(),
-                    "date_from_previous_period": self._date_from_previous_period(),
-                    "date_from": self._date_from(),
-                    "date_to": self._date_to(),
                     "bounce_breakdown_value": self._bounce_entry_pathname_breakdown(),
+                    "current_period": self._current_period_expression(),
+                    "previous_period": self._previous_period_expression(),
+                    "inside_periods": self._periods_expression(),
                 },
             )
         assert isinstance(query, ast.SelectQuery)
         return query
 
+    def _main_inner_query(self, breakdown):
+        query = parse_select(
+            """
+SELECT
+    any(person_id) AS filtered_person_id,
+    count() AS filtered_pageview_count,
+    {breakdown_value} AS breakdown_value,
+    session.session_id AS session_id,
+    any(session.$is_bounce) AS is_bounce,
+    min(session.$start_timestamp) as start_timestamp
+FROM events
+WHERE and({inside_periods}, {event_where}, {all_properties}, {where_breakdown})
+GROUP BY session_id, breakdown_value
+""",
+            timings=self.timings,
+            placeholders={
+                "breakdown_value": breakdown,
+                "event_where": self.event_type_expr,
+                "all_properties": self._all_properties(),
+                "where_breakdown": self.where_breakdown(),
+                "inside_periods": self._periods_expression(),
+            },
+        )
+
+        assert isinstance(query, ast.SelectQuery)
+
+        if self.conversion_count_expr and self.conversion_person_id_expr:
+            query.select.append(ast.Alias(alias="conversion_count", expr=self.conversion_count_expr))
+            query.select.append(ast.Alias(alias="conversion_person_id", expr=self.conversion_person_id_expr))
+
+        return query
+
+    def _period_comparison_tuple(self, column, alias, function_name):
+        return ast.Alias(
+            alias=alias,
+            expr=ast.Tuple(
+                exprs=[
+                    self._current_period_aggregate(function_name, column),
+                    self._previous_period_aggregate(function_name, column),
+                ]
+            ),
+        )
+
+    def _current_period_aggregate(self, function_name, column_name):
+        if not self.query_compare_to_date_range:
+            return ast.Call(name=function_name, args=[ast.Field(chain=[column_name])])
+
+        return self.period_aggregate(
+            function_name,
+            column_name,
+            self.query_date_range.date_from_as_hogql(),
+            self.query_date_range.date_to_as_hogql(),
+        )
+
+    def _previous_period_aggregate(self, function_name, column_name):
+        if not self.query_compare_to_date_range:
+            return ast.Constant(value=None)
+
+        return self.period_aggregate(
+            function_name,
+            column_name,
+            self.query_compare_to_date_range.date_from_as_hogql(),
+            self.query_compare_to_date_range.date_to_as_hogql(),
+        )
+
     def _event_properties(self) -> ast.Expr:
         properties = [
             p for p in self.query.properties + self._test_account_filters if get_property_type(p) in ["event", "person"]
@@ -461,22 +404,6 @@ def map_scroll_property(property: Union[EventPropertyFilter, PersonPropertyFilte
         ]
         return property_to_expr(properties, team=self.team, scope="event")
 
-    def _has_session_properties(self) -> bool:
-        return any(
-            get_property_type(p) == "session" for p in self.query.properties + self._test_account_filters
-        ) or self.query.breakdownBy in {
-            WebStatsBreakdown.INITIAL_CHANNEL_TYPE,
-            WebStatsBreakdown.INITIAL_REFERRING_DOMAIN,
-            WebStatsBreakdown.INITIAL_UTM_SOURCE,
-            WebStatsBreakdown.INITIAL_UTM_CAMPAIGN,
-            WebStatsBreakdown.INITIAL_UTM_MEDIUM,
-            WebStatsBreakdown.INITIAL_UTM_TERM,
-            WebStatsBreakdown.INITIAL_UTM_CONTENT,
-            WebStatsBreakdown.INITIAL_PAGE,
-            WebStatsBreakdown.EXIT_PAGE,
-            WebStatsBreakdown.INITIAL_UTM_SOURCE_MEDIUM_CAMPAIGN,
-        }
-
     def _session_properties(self) -> ast.Expr:
         properties = [
             p for p in self.query.properties + self._test_account_filters if get_property_type(p) == "session"
@@ -487,15 +414,6 @@ def _all_properties(self) -> ast.Expr:
         properties = self.query.properties + self._test_account_filters
         return property_to_expr(properties, team=self.team)
 
-    def _date_to(self) -> ast.Expr:
-        return self.query_date_range.date_to_as_hogql()
-
-    def _date_from(self) -> ast.Expr:
-        return self.query_date_range.date_from_as_hogql()
-
-    def _date_from_previous_period(self) -> ast.Expr:
-        return self.query_date_range.previous_period_date_from_as_hogql()
-
     def calculate(self):
         query = self.to_query()
         response = self.paginator.execute_hogql_query(
@@ -513,11 +431,14 @@ def calculate(self):
             results,
             {
                 0: self._join_with_aggregation_value,  # breakdown_value
-                1: lambda tuple, row: (self._unsample(tuple[0], row), self._unsample(tuple[1], row)),  # Views (tuple)
-                2: lambda tuple, row: (
+                1: lambda tuple, row: (  # Views (tuple)
+                    self._unsample(tuple[0], row),
+                    self._unsample(tuple[1], row),
+                ),
+                2: lambda tuple, row: (  # Visitors (tuple)
                     self._unsample(tuple[0], row),
                     self._unsample(tuple[1], row),
-                ),  # Visitors (tuple)
+                ),
             },
         )
 
@@ -525,9 +446,9 @@ def calculate(self):
 
         if self.query.breakdownBy == WebStatsBreakdown.LANGUAGE:
             # Keep only first 3 columns, we don't need the aggregation value in the frontend
-            results_mapped = [[column for idx, column in enumerate(row) if idx < 3] for row in results_mapped]
+            # Remove both the value and the column (used to generate table headers)
+            results_mapped = [row[:3] for row in results_mapped]
 
-            # Remove this before returning it to the frontend
             columns = (
                 [column for column in response.columns if column != "context.columns.aggregation_value"]
                 if response.columns is not None
diff --git a/posthog/hogql_queries/web_analytics/test/test_external_clicks_table.py b/posthog/hogql_queries/web_analytics/test/test_external_clicks_table.py
index 28cf62e2e8108..f56dea985f6ae 100644
--- a/posthog/hogql_queries/web_analytics/test/test_external_clicks_table.py
+++ b/posthog/hogql_queries/web_analytics/test/test_external_clicks_table.py
@@ -101,8 +101,8 @@ def test_increase_in_users(
 
         self.assertEqual(
             [
-                ["https://www.example.com/", 2, 2],
-                ["https://www.example.com/login", 1, 1],
+                ["https://www.example.com/", (2, 0), (2, 0)],
+                ["https://www.example.com/login", (1, 0), (1, 0)],
             ],
             results,
         )
@@ -129,9 +129,9 @@ def test_all_time(self):
 
         self.assertEqual(
             [
-                ["https://www.example.com/", 2, 2],
-                ["https://www.example.com/docs", 1, 1],
-                ["https://www.example.com/login", 1, 1],
+                ["https://www.example.com/", (2, 0), (2, 0)],
+                ["https://www.example.com/docs", (1, 0), (1, 0)],
+                ["https://www.example.com/login", (1, 0), (1, 0)],
             ],
             results,
         )
@@ -176,7 +176,7 @@ def test_dont_filter_test_accounts(self):
         results = self._run_external_clicks_table_query("2023-12-01", "2023-12-03", filter_test_accounts=False).results
 
         self.assertEqual(
-            [["https://www.example.com/", 1, 1], ["https://www.example.com/login", 1, 1]],
+            [["https://www.example.com/", (1, 0), (1, 0)], ["https://www.example.com/login", (1, 0), (1, 0)]],
             results,
         )
 
@@ -200,7 +200,7 @@ def test_strip_query_params(self):
         ).results
 
         self.assertEqual(
-            [["https://www.example.com/login", 1, 2]],
+            [["https://www.example.com/login", (1, 0), (2, 0)]],
             results_strip,
         )
 
@@ -209,7 +209,10 @@ def test_strip_query_params(self):
         ).results
 
         self.assertEqual(
-            [["https://www.example.com/login#bar", 1, 1], ["https://www.example.com/login?test=1#foo", 1, 1]],
+            [
+                ["https://www.example.com/login#bar", (1, 0), (1, 0)],
+                ["https://www.example.com/login?test=1#foo", (1, 0), (1, 0)],
+            ],
             results_no_strip,
         )
 
@@ -233,7 +236,7 @@ def test_should_exclude_subdomain_under_root(self):
 
         self.assertEqual(
             [
-                ["https://other.com/", 1, 1],
+                ["https://other.com/", (1, 0), (1, 0)],
             ],
             results,
         )
@@ -259,7 +262,7 @@ def test_should_exclude_subdomain_with_shared_root(self):
 
         self.assertEqual(
             [
-                ["https://other.com/", 1, 1],
+                ["https://other.com/", (1, 0), (1, 0)],
             ],
             results,
         )
diff --git a/posthog/hogql_queries/web_analytics/test/test_web_overview.py b/posthog/hogql_queries/web_analytics/test/test_web_overview.py
index 3e9b570f57b9e..3a5c421cb890a 100644
--- a/posthog/hogql_queries/web_analytics/test/test_web_overview.py
+++ b/posthog/hogql_queries/web_analytics/test/test_web_overview.py
@@ -9,6 +9,7 @@
 from posthog.models import Action, Element
 from posthog.models.utils import uuid7
 from posthog.schema import (
+    CompareFilter,
     WebOverviewQuery,
     DateRange,
     SessionTableVersion,
@@ -83,7 +84,7 @@ def _run_web_overview_query(
         query = WebOverviewQuery(
             dateRange=DateRange(date_from=date_from, date_to=date_to),
             properties=[],
-            compare=compare,
+            compareFilter=CompareFilter(compare=compare) if compare else None,
             modifiers=modifiers,
             filterTestAccounts=filter_test_accounts,
             conversionGoal=ActionConversionGoal(actionId=action.id)
@@ -231,6 +232,53 @@ def test_all_time(self):
         self.assertEqual(None, bounce.previous)
         self.assertEqual(None, bounce.changeFromPreviousPct)
 
+    def test_comparison(self):
+        s1a = str(uuid7("2023-12-02"))
+        s1b = str(uuid7("2023-12-12"))
+        s2 = str(uuid7("2023-12-11"))
+        self._create_events(
+            [
+                ("p1", [("2023-12-02", s1a), ("2023-12-03", s1a), ("2023-12-12", s1b)]),
+                ("p2", [("2023-12-11", s2)]),
+            ]
+        )
+
+        results = self._run_web_overview_query(
+            "2023-12-06",
+            "2023-12-13",
+            compare=True,
+        ).results
+
+        visitors = results[0]
+        self.assertEqual("visitors", visitors.key)
+        self.assertEqual(2, visitors.value)
+        self.assertEqual(1, visitors.previous)
+        self.assertEqual(100, visitors.changeFromPreviousPct)
+
+        views = results[1]
+        self.assertEqual("views", views.key)
+        self.assertEqual(2, views.value)
+        self.assertEqual(2, views.previous)
+        self.assertEqual(0, views.changeFromPreviousPct)
+
+        sessions = results[2]
+        self.assertEqual("sessions", sessions.key)
+        self.assertEqual(2, sessions.value)
+        self.assertEqual(1, sessions.previous)
+        self.assertEqual(100, sessions.changeFromPreviousPct)
+
+        duration_s = results[3]
+        self.assertEqual("session duration", duration_s.key)
+        self.assertEqual(0, duration_s.value)
+        self.assertEqual(60 * 60 * 24, duration_s.previous)
+        self.assertEqual(-100, duration_s.changeFromPreviousPct)
+
+        bounce = results[4]
+        self.assertEqual("bounce rate", bounce.key)
+        self.assertAlmostEqual(100, bounce.value)
+        self.assertEqual(0, bounce.previous)
+        self.assertEqual(None, bounce.changeFromPreviousPct)
+
     def test_filter_test_accounts(self):
         s1 = str(uuid7("2023-12-02"))
         # Create 1 test account
diff --git a/posthog/hogql_queries/web_analytics/test/test_web_stats_table.py b/posthog/hogql_queries/web_analytics/test/test_web_stats_table.py
index ae4b48b0632c1..74c12e30586cf 100644
--- a/posthog/hogql_queries/web_analytics/test/test_web_stats_table.py
+++ b/posthog/hogql_queries/web_analytics/test/test_web_stats_table.py
@@ -3,16 +3,19 @@
 from freezegun import freeze_time
 
 from posthog.hogql_queries.web_analytics.stats_table import WebStatsTableQueryRunner
-from posthog.models import Cohort
+from posthog.models import Action, Cohort, Element
 from posthog.models.utils import uuid7
 from posthog.schema import (
     DateRange,
+    CompareFilter,
     WebStatsTableQuery,
     WebStatsBreakdown,
     EventPropertyFilter,
     PropertyOperator,
     SessionTableVersion,
     HogQLQueryModifiers,
+    CustomEventConversionGoal,
+    ActionConversionGoal,
 )
 from posthog.test.base import (
     APIBaseTest,
@@ -38,13 +41,27 @@ def _create_events(self, data, event="$pageview"):
                         },
                     )
                 )
-            for timestamp, session_id, pathname in timestamps:
+            for timestamp, session_id, *extra in timestamps:
+                url = None
+                elements = None
+                if event == "$pageview":
+                    url = extra[0] if extra else None
+                elif event == "$autocapture":
+                    elements = extra[0] if extra else None
+                properties = extra[1] if extra and len(extra) > 1 else {}
+
                 _create_event(
                     team=self.team,
                     event=event,
                     distinct_id=id,
                     timestamp=timestamp,
-                    properties={"$session_id": session_id, "$pathname": pathname},
+                    properties={
+                        "$session_id": session_id,
+                        "$pathname": url,
+                        "$current_url": url,
+                        **properties,
+                    },
+                    elements=elements,
                 )
         return person_result
 
@@ -107,6 +124,9 @@ def _run_web_stats_table_query(
         include_bounce_rate=False,
         include_scroll_depth=False,
         properties=None,
+        compare_filter=None,
+        action: Optional[Action] = None,
+        custom_event: Optional[str] = None,
         session_table_version: SessionTableVersion = SessionTableVersion.V2,
         filter_test_accounts: Optional[bool] = False,
     ):
@@ -119,6 +139,12 @@ def _run_web_stats_table_query(
             doPathCleaning=bool(path_cleaning_filters),
             includeBounceRate=include_bounce_rate,
             includeScrollDepth=include_scroll_depth,
+            compareFilter=compare_filter,
+            conversionGoal=ActionConversionGoal(actionId=action.id)
+            if action
+            else CustomEventConversionGoal(customEventName=custom_event)
+            if custom_event
+            else None,
             filterTestAccounts=filter_test_accounts,
         )
         self.team.path_cleaning_filters = path_cleaning_filters or []
@@ -147,8 +173,8 @@ def test_increase_in_users(self):
 
         self.assertEqual(
             [
-                ["/", (2, 0), (2, 0)],
-                ["/login", (1, 0), (1, 0)],
+                ["/", (2, None), (2, None)],
+                ["/login", (1, None), (1, None)],
             ],
             results,
         )
@@ -168,9 +194,33 @@ def test_all_time(self):
 
         self.assertEqual(
             [
-                ["/", (2, 0), (2, 0)],
+                ["/", (2, None), (2, None)],
+                ["/docs", (1, None), (1, None)],
+                ["/login", (1, None), (1, None)],
+            ],
+            results,
+        )
+
+    def test_comparison(self):
+        s1a = str(uuid7("2023-12-02"))
+        s1b = str(uuid7("2023-12-13"))
+        s2 = str(uuid7("2023-12-10"))
+        self._create_events(
+            [
+                ("p1", [("2023-12-02", s1a, "/"), ("2023-12-03", s1a, "/login"), ("2023-12-13", s1b, "/docs")]),
+                ("p2", [("2023-12-10", s2, "/")]),
+            ]
+        )
+
+        results = self._run_web_stats_table_query(
+            "2023-12-06", "2023-12-13", compare_filter=CompareFilter(compare=True)
+        ).results
+
+        self.assertEqual(
+            [
+                ["/", (1, 1), (1, 1)],
                 ["/docs", (1, 0), (1, 0)],
-                ["/login", (1, 0), (1, 0)],
+                ["/login", (0, 1), (0, 1)],
             ],
             results,
         )
@@ -195,7 +245,7 @@ def test_dont_filter_test_accounts(self):
         results = self._run_web_stats_table_query("2023-12-01", "2023-12-03", filter_test_accounts=False).results
 
         self.assertEqual(
-            [["/", (1, 0), (1, 0)], ["/login", (1, 0), (1, 0)]],
+            [["/", (1, None), (1, None)], ["/login", (1, None), (1, None)]],
             results,
         )
 
@@ -235,7 +285,7 @@ def test_limit(self):
         response_1 = self._run_web_stats_table_query("all", "2023-12-15", limit=1)
         self.assertEqual(
             [
-                ["/", (2, 0), (2, 0)],
+                ["/", (2, None), (2, None)],
             ],
             response_1.results,
         )
@@ -244,8 +294,8 @@ def test_limit(self):
         response_2 = self._run_web_stats_table_query("all", "2023-12-15", limit=2)
         self.assertEqual(
             [
-                ["/", (2, 0), (2, 0)],
-                ["/login", (1, 0), (1, 0)],
+                ["/", (2, None), (2, None)],
+                ["/login", (1, None), (1, None)],
             ],
             response_2.results,
         )
@@ -280,10 +330,10 @@ def test_path_filters(self):
 
         self.assertEqual(
             [
-                ["/cleaned/:id", (2, 0), (2, 0)],
-                ["/cleaned/:id/path/:id", (1, 0), (1, 0)],
-                ["/not-cleaned", (1, 0), (1, 0)],
-                ["/thing_c", (1, 0), (1, 0)],
+                ["/cleaned/:id", (2, None), (2, None)],
+                ["/cleaned/:id/path/:id", (1, None), (1, None)],
+                ["/not-cleaned", (1, None), (1, None)],
+                ["/thing_c", (1, None), (1, None)],
             ],
             results,
         )
@@ -587,7 +637,7 @@ def test_entry_bounce_rate_one_user(self):
 
         self.assertEqual(
             [
-                ["/a", (1, 0), (3, 0), (0, None)],
+                ["/a", (1, None), (3, None), (0, None)],
             ],
             results,
         )
@@ -626,7 +676,7 @@ def test_entry_bounce_rate(self):
 
         self.assertEqual(
             [
-                ["/a", (3, 0), (8, 0), (1 / 3, None)],
+                ["/a", (3, None), (8, None), (1 / 3, None)],
             ],
             results,
         )
@@ -666,7 +716,7 @@ def test_entry_bounce_rate_with_property(self):
 
         self.assertEqual(
             [
-                ["/a", (3, 0), (4, 0), (1 / 3, None)],
+                ["/a", (3, None), (4, None), (1 / 3, None)],
             ],
             results,
         )
@@ -695,7 +745,7 @@ def test_entry_bounce_rate_path_cleaning(self):
 
         self.assertEqual(
             [
-                ["/a/:id", (1, 0), (3, 0), (0, None)],
+                ["/a/:id", (1, None), (3, None), (0, None)],
             ],
             results,
         )
@@ -744,8 +794,8 @@ def test_source_medium_campaign(self):
 
         self.assertEqual(
             [
-                ["google / (none) / (none)", (1, 0), (1, 0)],
-                ["news.ycombinator.com / referral / (none)", (1, 0), (1, 0)],
+                ["google / (none) / (none)", (1, None), (1, None)],
+                ["news.ycombinator.com / referral / (none)", (1, None), (1, None)],
             ],
             results,
         )
@@ -795,7 +845,7 @@ def test_null_in_utm_tags(self):
         ).results
 
         self.assertEqual(
-            [["google", (1, 0), (1, 0)], [None, (1, 0), (1, 0)]],
+            [["google", (1, None), (1, None)], [None, (1, None), (1, None)]],
             results,
         )
 
@@ -845,7 +895,7 @@ def test_is_not_set_filter(self):
         ).results
 
         self.assertEqual(
-            [[None, (1, 0), (1, 0)]],
+            [[None, (1, None), (1, None)]],
             results,
         )
 
@@ -881,7 +931,7 @@ def test_same_user_multiple_sessions(self):
             "2024-07-31",
             breakdown_by=WebStatsBreakdown.INITIAL_UTM_SOURCE,
         ).results
-        assert [["google", (1, 0), (2, 0)]] == results_session
+        assert [["google", (1, None), (2, None)]] == results_session
 
         # Try this with a query that uses event properties
         results_event = self._run_web_stats_table_query(
@@ -889,7 +939,7 @@ def test_same_user_multiple_sessions(self):
             "2024-07-31",
             breakdown_by=WebStatsBreakdown.PAGE,
         ).results
-        assert [["/path", (1, 0), (2, 0)]] == results_event
+        assert [["/path", (1, None), (2, None)]] == results_event
 
         # Try this with a query using the bounce rate
         results_event = self._run_web_stats_table_query(
@@ -938,16 +988,14 @@ def test_no_session_id(self):
         ).results
         assert [] == results
 
-        # Do show event property breakdowns of events with no session id
-        # but it will return 0 views because we depend on session.$start_timestamp
-        # to figure out the previous/current values
+        # Show event property breakdowns of page view events even without session id
         results = self._run_web_stats_table_query(
             "all",
             "2024-07-31",
             breakdown_by=WebStatsBreakdown.PAGE,
         ).results
 
-        assert [["/path", (0, 0), (0, 0)]] == results
+        assert [["/path", (1, None), (1, None)]] == results
 
     def test_cohort_test_filters(self):
         d1 = "d1"
@@ -1009,7 +1057,7 @@ def test_cohort_test_filters(self):
             breakdown_by=WebStatsBreakdown.PAGE,
         ).results
 
-        assert results == [["/path1", (1, 0), (1, 0)]]
+        assert results == [["/path1", (1, None), (1, None)]]
 
     def test_language_filter(self):
         d1, s1 = "d1", str(uuid7("2024-07-30"))
@@ -1135,10 +1183,10 @@ def test_timezone_filter_general(self):
 
         # Brasilia UTC-3, New York UTC-4, Calcutta UTC+5:30, UTC
         assert results == [
-            [-3, (1, 1), (4, 1)],
-            [-4, (1, 1), (3, 1)],
-            [5.5, (1, 1), (2, 1)],
-            [0, (1, 1), (1, 1)],
+            [-3, (1, None), (4, None)],
+            [-4, (1, None), (3, None)],
+            [5.5, (1, None), (2, None)],
+            [0, (1, None), (1, None)],
         ]
 
     def test_timezone_filter_dst_change(self):
@@ -1168,7 +1216,7 @@ def test_timezone_filter_dst_change(self):
         ).results
 
         # Change from UTC-2 to UTC-3 in the middle of the night
-        assert results == [[-3, (1, 0), (4, 0)], [-2, (1, 0), (2, 0)]]
+        assert results == [[-3, (1, None), (4, None)], [-2, (1, None), (2, None)]]
 
     def test_timezone_filter_with_invalid_timezone(self):
         date = "2024-07-30"
@@ -1255,3 +1303,217 @@ def test_timezone_filter_with_empty_timezone(self):
 
         # Don't crash, treat all of them null
         assert results == []
+
+    def test_conversion_goal_no_conversions(self):
+        s1 = str(uuid7("2023-12-01"))
+        self._create_events(
+            [
+                ("p1", [("2023-12-01", s1, "https://www.example.com/foo")]),
+            ]
+        )
+
+        action = Action.objects.create(
+            team=self.team,
+            name="Visited Bar",
+            steps_json=[{"event": "$pageview", "url": "https://www.example.com/bar", "url_matching": "regex"}],
+        )
+
+        response = self._run_web_stats_table_query(
+            "2023-12-01", "2023-12-03", breakdown_by=WebStatsBreakdown.PAGE, action=action
+        )
+
+        assert [["https://www.example.com/foo", (1, None), (0, None), (0, None), (0, None)]] == response.results
+        assert [
+            "context.columns.breakdown_value",
+            "context.columns.visitors",
+            "context.columns.total_conversions",
+            "context.columns.unique_conversions",
+            "context.columns.conversion_rate",
+        ] == response.columns
+
+    def test_conversion_goal_one_pageview_conversion(self):
+        s1 = str(uuid7("2023-12-01"))
+        self._create_events(
+            [
+                ("p1", [("2023-12-01", s1, "https://www.example.com/foo")]),
+            ]
+        )
+
+        action = Action.objects.create(
+            team=self.team,
+            name="Visited Foo",
+            steps_json=[
+                {
+                    "event": "$pageview",
+                    "url": "https://www.example.com/foo",
+                    "url_matching": "regex",
+                }
+            ],
+        )
+
+        response = self._run_web_stats_table_query(
+            "2023-12-01", "2023-12-03", breakdown_by=WebStatsBreakdown.PAGE, action=action
+        )
+
+        response = self._run_web_stats_table_query(
+            "2023-12-01", "2023-12-03", breakdown_by=WebStatsBreakdown.PAGE, action=action
+        )
+
+        assert [["https://www.example.com/foo", (1, None), (1, None), (1, None), (1, None)]] == response.results
+        assert [
+            "context.columns.breakdown_value",
+            "context.columns.visitors",
+            "context.columns.total_conversions",
+            "context.columns.unique_conversions",
+            "context.columns.conversion_rate",
+        ] == response.columns
+
+    def test_conversion_goal_one_custom_event_conversion(self):
+        s1 = str(uuid7("2023-12-01"))
+        self._create_events(
+            [
+                ("p1", [("2023-12-01", s1, "https://www.example.com/foo")]),
+            ],
+            event="custom_event",
+        )
+
+        response = self._run_web_stats_table_query(
+            "2023-12-01",
+            "2023-12-03",
+            breakdown_by=WebStatsBreakdown.INITIAL_UTM_SOURCE,  # Allow the breakdown value to be non-null
+            custom_event="custom_event",
+        )
+
+        assert [[None, (1, None), (1, None), (1, None), (1, None)]] == response.results
+        assert [
+            "context.columns.breakdown_value",
+            "context.columns.visitors",
+            "context.columns.total_conversions",
+            "context.columns.unique_conversions",
+            "context.columns.conversion_rate",
+        ] == response.columns
+
+    def test_conversion_goal_one_custom_action_conversion(self):
+        s1 = str(uuid7("2023-12-01"))
+        self._create_events(
+            [
+                ("p1", [("2023-12-01", s1)]),
+            ],
+            event="custom_event",
+        )
+
+        action = Action.objects.create(
+            team=self.team,
+            name="Did Custom Event",
+            steps_json=[
+                {
+                    "event": "custom_event",
+                }
+            ],
+        )
+
+        response = self._run_web_stats_table_query(
+            "2023-12-01",
+            "2023-12-03",
+            breakdown_by=WebStatsBreakdown.INITIAL_UTM_SOURCE,  # Allow the breakdown value to be non-null
+            action=action,
+        )
+
+        assert [[None, (1, None), (1, None), (1, None), (1, None)]] == response.results
+        assert [
+            "context.columns.breakdown_value",
+            "context.columns.visitors",
+            "context.columns.total_conversions",
+            "context.columns.unique_conversions",
+            "context.columns.conversion_rate",
+        ] == response.columns
+
+    def test_conversion_goal_one_autocapture_conversion(self):
+        s1 = str(uuid7("2023-12-01"))
+        self._create_events(
+            [
+                ("p1", [("2023-12-01", s1, [Element(nth_of_type=1, nth_child=0, tag_name="button", text="Pay $10")])]),
+            ],
+            event="$autocapture",
+        )
+
+        action = Action.objects.create(
+            team=self.team,
+            name="Paid $10",
+            steps_json=[
+                {
+                    "event": "$autocapture",
+                    "tag_name": "button",
+                    "text": "Pay $10",
+                }
+            ],
+        )
+
+        response = self._run_web_stats_table_query(
+            "2023-12-01",
+            "2023-12-03",
+            breakdown_by=WebStatsBreakdown.INITIAL_UTM_SOURCE,  # Allow the breakdown value to be non-null
+            action=action,
+        )
+
+        assert [[None, (1, None), (1, None), (1, None), (1, None)]] == response.results
+        assert [
+            "context.columns.breakdown_value",
+            "context.columns.visitors",
+            "context.columns.total_conversions",
+            "context.columns.unique_conversions",
+            "context.columns.conversion_rate",
+        ] == response.columns
+
+    def test_conversion_rate(self):
+        s1 = str(uuid7("2023-12-01"))
+        s2 = str(uuid7("2023-12-01"))
+        s3 = str(uuid7("2023-12-01"))
+
+        self._create_events(
+            [
+                (
+                    "p1",
+                    [
+                        ("2023-12-01", s1, "https://www.example.com/foo"),
+                        ("2023-12-01", s1, "https://www.example.com/foo"),
+                    ],
+                ),
+                (
+                    "p2",
+                    [
+                        ("2023-12-01", s2, "https://www.example.com/foo"),
+                        ("2023-12-01", s2, "https://www.example.com/bar"),
+                    ],
+                ),
+                ("p3", [("2023-12-01", s3, "https://www.example.com/bar")]),
+            ]
+        )
+
+        action = Action.objects.create(
+            team=self.team,
+            name="Visited Foo",
+            steps_json=[
+                {
+                    "event": "$pageview",
+                    "url": "https://www.example.com/foo",
+                    "url_matching": "regex",
+                }
+            ],
+        )
+
+        response = self._run_web_stats_table_query(
+            "2023-12-01", "2023-12-03", breakdown_by=WebStatsBreakdown.PAGE, action=action
+        )
+
+        assert [
+            ["https://www.example.com/foo", (2, None), (3, None), (2, None), (1, None)],
+            ["https://www.example.com/bar", (2, None), (0, None), (0, None), (0, None)],
+        ] == response.results
+        assert [
+            "context.columns.breakdown_value",
+            "context.columns.visitors",
+            "context.columns.total_conversions",
+            "context.columns.unique_conversions",
+            "context.columns.conversion_rate",
+        ] == response.columns
diff --git a/posthog/hogql_queries/web_analytics/web_analytics_query_runner.py b/posthog/hogql_queries/web_analytics/web_analytics_query_runner.py
index b73772ef79a90..5c97e3ce6f78c 100644
--- a/posthog/hogql_queries/web_analytics/web_analytics_query_runner.py
+++ b/posthog/hogql_queries/web_analytics/web_analytics_query_runner.py
@@ -11,12 +11,17 @@
 from posthog.caching.insights_api import BASE_MINIMUM_INSIGHT_REFRESH_INTERVAL, REDUCED_MINIMUM_INSIGHT_REFRESH_INTERVAL
 from posthog.hogql import ast
 from posthog.hogql.parser import parse_expr, parse_select
-from posthog.hogql.property import property_to_expr
+from posthog.hogql.property import property_to_expr, action_to_expr
 from posthog.hogql.query import execute_hogql_query
 from posthog.hogql_queries.query_runner import QueryRunner
 from posthog.hogql_queries.utils.query_date_range import QueryDateRange
+from posthog.hogql_queries.utils.query_compare_to_date_range import QueryCompareToDateRange
+from posthog.hogql_queries.utils.query_previous_period_date_range import QueryPreviousPeriodDateRange
+from posthog.models import Action
 from posthog.models.filters.mixins.utils import cached_property
 from posthog.schema import (
+    ActionConversionGoal,
+    CustomEventConversionGoal,
     EventPropertyFilter,
     WebOverviewQuery,
     WebStatsTableQuery,
@@ -44,6 +49,73 @@ def query_date_range(self):
             now=datetime.now(),
         )
 
+    @cached_property
+    def query_compare_to_date_range(self):
+        if self.query.compareFilter is not None:
+            if isinstance(self.query.compareFilter.compare_to, str):
+                return QueryCompareToDateRange(
+                    date_range=self.query.dateRange,
+                    team=self.team,
+                    interval=None,
+                    now=datetime.now(),
+                    compare_to=self.query.compareFilter.compare_to,
+                )
+            elif self.query.compareFilter.compare:
+                return QueryPreviousPeriodDateRange(
+                    date_range=self.query.dateRange,
+                    team=self.team,
+                    interval=None,
+                    now=datetime.now(),
+                )
+
+        return None
+
+    def _current_period_expression(self, field="start_timestamp"):
+        return ast.Call(
+            name="and",
+            args=[
+                ast.CompareOperation(
+                    left=ast.Field(chain=[field]),
+                    right=self.query_date_range.date_from_as_hogql(),
+                    op=ast.CompareOperationOp.GtEq,
+                ),
+                ast.CompareOperation(
+                    left=ast.Field(chain=[field]),
+                    right=self.query_date_range.date_to_as_hogql(),
+                    op=ast.CompareOperationOp.Lt,
+                ),
+            ],
+        )
+
+    def _previous_period_expression(self, field="start_timestamp"):
+        if not self.query_compare_to_date_range:
+            return ast.Constant(value=None)
+
+        return ast.Call(
+            name="and",
+            args=[
+                ast.CompareOperation(
+                    left=ast.Field(chain=[field]),
+                    right=self.query_compare_to_date_range.date_from_as_hogql(),
+                    op=ast.CompareOperationOp.GtEq,
+                ),
+                ast.CompareOperation(
+                    left=ast.Field(chain=[field]),
+                    right=self.query_compare_to_date_range.date_to_as_hogql(),
+                    op=ast.CompareOperationOp.Lt,
+                ),
+            ],
+        )
+
+    def _periods_expression(self, field="timestamp"):
+        return ast.Call(
+            name="or",
+            args=[
+                self._current_period_expression(field),
+                self._previous_period_expression(field),
+            ],
+        )
+
     @cached_property
     def pathname_property_filter(self) -> Optional[EventPropertyFilter]:
         for p in self.query.properties:
@@ -57,6 +129,57 @@ def property_filters_without_pathname(
     ) -> list[Union[EventPropertyFilter, PersonPropertyFilter, SessionPropertyFilter]]:
         return [p for p in self.query.properties if p.key != "$pathname"]
 
+    @cached_property
+    def conversion_goal_expr(self) -> Optional[ast.Expr]:
+        if isinstance(self.query.conversionGoal, ActionConversionGoal):
+            action = Action.objects.get(pk=self.query.conversionGoal.actionId, team__project_id=self.team.project_id)
+            return action_to_expr(action)
+        elif isinstance(self.query.conversionGoal, CustomEventConversionGoal):
+            return ast.CompareOperation(
+                left=ast.Field(chain=["events", "event"]),
+                op=ast.CompareOperationOp.Eq,
+                right=ast.Constant(value=self.query.conversionGoal.customEventName),
+            )
+        else:
+            return None
+
+    @cached_property
+    def conversion_count_expr(self) -> Optional[ast.Expr]:
+        if self.conversion_goal_expr:
+            return ast.Call(name="countIf", args=[self.conversion_goal_expr])
+        else:
+            return None
+
+    @cached_property
+    def conversion_person_id_expr(self) -> Optional[ast.Expr]:
+        if self.conversion_goal_expr:
+            return ast.Call(
+                name="any",
+                args=[
+                    ast.Call(
+                        name="if",
+                        args=[
+                            self.conversion_goal_expr,
+                            ast.Field(chain=["events", "person_id"]),
+                            ast.Constant(value=None),
+                        ],
+                    )
+                ],
+            )
+        else:
+            return None
+
+    @cached_property
+    def event_type_expr(self) -> ast.Expr:
+        pageview_expr = ast.CompareOperation(
+            op=ast.CompareOperationOp.Eq, left=ast.Field(chain=["event"]), right=ast.Constant(value="$pageview")
+        )
+
+        if self.conversion_goal_expr:
+            return ast.Call(name="or", args=[pageview_expr, self.conversion_goal_expr])
+        else:
+            return pageview_expr
+
     def period_aggregate(self, function_name, column_name, start, end, alias=None, params=None):
         expr = ast.Call(
             name=function_name + "If",
diff --git a/posthog/hogql_queries/web_analytics/web_goals.py b/posthog/hogql_queries/web_analytics/web_goals.py
index 04e13ab6d508e..7bd36573340fb 100644
--- a/posthog/hogql_queries/web_analytics/web_goals.py
+++ b/posthog/hogql_queries/web_analytics/web_goals.py
@@ -29,7 +29,9 @@ def to_query(self) -> ast.SelectQuery | ast.SelectSetQuery:
             start = self.query_date_range.date_from_as_hogql()
             end = self.query_date_range.date_to_as_hogql()
 
-        actions = Action.objects.filter(team=self.team, deleted=False).order_by("pinned_at", "-last_calculated_at")[:5]
+        actions = Action.objects.filter(team__project_id=self.team.project_id, deleted=False).order_by(
+            "pinned_at", "-last_calculated_at"
+        )[:5]
         if not actions:
             raise NoActionsError("No actions found")
 
diff --git a/posthog/hogql_queries/web_analytics/web_overview.py b/posthog/hogql_queries/web_analytics/web_overview.py
index 24ba05dbc8096..8eb58f32adefb 100644
--- a/posthog/hogql_queries/web_analytics/web_overview.py
+++ b/posthog/hogql_queries/web_analytics/web_overview.py
@@ -1,24 +1,18 @@
 from typing import Optional, Union
 import math
 
-from django.utils.timezone import datetime
-
 from posthog.hogql import ast
 from posthog.hogql.parser import parse_select
-from posthog.hogql.property import property_to_expr, get_property_type, action_to_expr
+from posthog.hogql.property import property_to_expr, get_property_type
 from posthog.hogql.query import execute_hogql_query
-from posthog.hogql_queries.utils.query_date_range import QueryDateRange
 from posthog.hogql_queries.web_analytics.web_analytics_query_runner import (
     WebAnalyticsQueryRunner,
 )
-from posthog.models import Action
 from posthog.models.filters.mixins.utils import cached_property
 from posthog.schema import (
     CachedWebOverviewQueryResponse,
     WebOverviewQueryResponse,
     WebOverviewQuery,
-    ActionConversionGoal,
-    CustomEventConversionGoal,
     SessionTableVersion,
 )
 
@@ -72,15 +66,6 @@ def calculate(self):
             dateTo=self.query_date_range.date_to_str,
         )
 
-    @cached_property
-    def query_date_range(self):
-        return QueryDateRange(
-            date_range=self.query.dateRange,
-            team=self.team,
-            interval=None,
-            now=datetime.now(),
-        )
-
     def all_properties(self) -> ast.Expr:
         properties = self.query.properties + self._test_account_filters
         return property_to_expr(properties, team=self.team)
@@ -97,39 +82,6 @@ def session_properties(self) -> ast.Expr:
         ]
         return property_to_expr(properties, team=self.team, scope="event")
 
-    @cached_property
-    def conversion_goal_expr(self) -> Optional[ast.Expr]:
-        if isinstance(self.query.conversionGoal, ActionConversionGoal):
-            action = Action.objects.get(pk=self.query.conversionGoal.actionId, team__project_id=self.team.project_id)
-            return action_to_expr(action)
-        elif isinstance(self.query.conversionGoal, CustomEventConversionGoal):
-            return ast.CompareOperation(
-                left=ast.Field(chain=["events", "event"]),
-                op=ast.CompareOperationOp.Eq,
-                right=ast.Constant(value=self.query.conversionGoal.customEventName),
-            )
-        else:
-            return None
-
-    @cached_property
-    def conversion_person_id_expr(self) -> Optional[ast.Expr]:
-        if self.conversion_goal_expr:
-            return ast.Call(
-                name="any",
-                args=[
-                    ast.Call(
-                        name="if",
-                        args=[
-                            self.conversion_goal_expr,
-                            ast.Field(chain=["events", "person_id"]),
-                            ast.Constant(value=None),
-                        ],
-                    )
-                ],
-            )
-        else:
-            return None
-
     @cached_property
     def pageview_count_expression(self) -> ast.Expr:
         if self.conversion_goal_expr:
@@ -146,30 +98,8 @@ def pageview_count_expression(self) -> ast.Expr:
         else:
             return ast.Call(name="count", args=[])
 
-    @cached_property
-    def conversion_count_expr(self) -> Optional[ast.Expr]:
-        if self.conversion_goal_expr:
-            return ast.Call(name="countIf", args=[self.conversion_goal_expr])
-        else:
-            return None
-
-    @cached_property
-    def event_type_expr(self) -> ast.Expr:
-        pageview_expr = ast.CompareOperation(
-            op=ast.CompareOperationOp.Eq, left=ast.Field(chain=["event"]), right=ast.Constant(value="$pageview")
-        )
-
-        if self.conversion_goal_expr and self.conversion_goal_expr != ast.Constant(value=None):
-            return ast.Call(name="or", args=[pageview_expr, self.conversion_goal_expr])
-        else:
-            return pageview_expr
-
     @cached_property
     def inner_select(self) -> ast.SelectQuery:
-        start = self.query_date_range.previous_period_date_from_as_hogql()
-        mid = self.query_date_range.date_from_as_hogql()
-        end = self.query_date_range.date_to_as_hogql()
-
         parsed_select = parse_select(
             """
 SELECT
@@ -180,23 +110,19 @@ def inner_select(self) -> ast.SelectQuery:
 WHERE and(
     events.`$session_id` IS NOT NULL,
     {event_type_expr},
-    timestamp >= {date_range_start},
-    timestamp < {date_range_end},
+    {inside_timestamp_period},
     {event_properties},
     {session_properties}
 )
 GROUP BY session_id
-HAVING and(
-    start_timestamp >= {date_range_start},
-    start_timestamp < {date_range_end}
-)
+HAVING {inside_start_timestamp_period}
         """,
             placeholders={
-                "date_range_start": start if self.query.compare else mid,
-                "date_range_end": end,
                 "event_properties": self.event_properties(),
                 "session_properties": self.session_properties(),
                 "event_type_expr": self.event_type_expr,
+                "inside_timestamp_period": self._periods_expression("timestamp"),
+                "inside_start_timestamp_period": self._periods_expression("start_timestamp"),
             },
         )
         assert isinstance(parsed_select, ast.SelectQuery)
@@ -231,21 +157,31 @@ def inner_select(self) -> ast.SelectQuery:
 
     @cached_property
     def outer_select(self) -> ast.SelectQuery:
-        start = self.query_date_range.previous_period_date_from_as_hogql()
-        mid = self.query_date_range.date_from_as_hogql()
-        end = self.query_date_range.date_to_as_hogql()
-
         def current_period_aggregate(function_name, column_name, alias, params=None):
-            if not self.query.compare:
+            if not self.query_compare_to_date_range:
                 return ast.Call(name=function_name, params=params, args=[ast.Field(chain=[column_name])])
 
-            return self.period_aggregate(function_name, column_name, mid, end, alias=alias, params=params)
+            return self.period_aggregate(
+                function_name,
+                column_name,
+                self.query_date_range.date_from_as_hogql(),
+                self.query_date_range.date_to_as_hogql(),
+                alias=alias,
+                params=params,
+            )
 
         def previous_period_aggregate(function_name, column_name, alias, params=None):
-            if not self.query.compare:
+            if not self.query_compare_to_date_range:
                 return ast.Alias(alias=alias, expr=ast.Constant(value=None))
 
-            return self.period_aggregate(function_name, column_name, start, mid, alias=alias, params=params)
+            return self.period_aggregate(
+                function_name,
+                column_name,
+                self.query_compare_to_date_range.date_from_as_hogql(),
+                self.query_compare_to_date_range.date_to_as_hogql(),
+                alias=alias,
+                params=params,
+            )
 
         if self.query.conversionGoal:
             select = [
diff --git a/posthog/management/commands/create_channel_definitions_file.py b/posthog/management/commands/create_channel_definitions_file.py
index 6c254886084e4..8a62b6ec22588 100644
--- a/posthog/management/commands/create_channel_definitions_file.py
+++ b/posthog/management/commands/create_channel_definitions_file.py
@@ -231,6 +231,10 @@ def handle(self, *args, **options):
             # discord
             "discord.com",
             "discordapp.gg",
+            # twitter
+            "twitter.com",
+            "t.co",
+            "x.com",
         ):
             entries[(social_domain, EntryKind.source)] = SourceEntry("Social", "Paid Social", "Organic Social")
 
diff --git a/posthog/management/commands/delete_persons.py b/posthog/management/commands/delete_persons.py
new file mode 100644
index 0000000000000..b6e70aded78e6
--- /dev/null
+++ b/posthog/management/commands/delete_persons.py
@@ -0,0 +1,119 @@
+import logging
+
+from django.db import connection
+import structlog
+from django.core.management.base import BaseCommand
+
+
+logger = structlog.get_logger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class Command(BaseCommand):
+    help = "Delete a batch of persons from postgres"
+
+    def add_arguments(self, parser):
+        parser.add_argument("--team-id", default=None, type=int, help="Specify a team to delete persons from.")
+        parser.add_argument(
+            "--person-ids", default=None, type=str, help="Specify a list of comma separated person ids to be deleted."
+        )
+        parser.add_argument("--batch-size", default=1000, type=int, help="Number of rows to be deleted per batch")
+        parser.add_argument("--batches", default=1, type=int, help="Number of batches to run")
+        parser.add_argument("--live-run", action="store_true", help="Run changes, default is dry-run")
+
+    def handle(self, *args, **options):
+        run(options)
+
+
+def run(options):
+    live_run = options["live_run"]
+    team_id = options["team_id"]
+    person_ids = options["person_ids"].split(",") if options["person_ids"] else None
+    batches = options["batches"]
+    batch_size = options["batch_size"]
+
+    if not team_id:
+        logger.error("You must specify --team-id to run this script")
+        return exit(1)
+
+    # Print the plan
+    logger.info("Plan:")
+    if team_id:
+        logger.info(f"-> Team ID: {team_id}")
+    if person_ids:
+        logger.info(f"-> Person IDs: {person_ids}")
+    logger.info(f"-> Batches: {batches} of {batch_size}")
+
+    select_query = f"""
+        SELECT id
+        FROM posthog_person
+        WHERE team_id=%(team_id)s {f"AND id IN ({person_ids})" if person_ids else ""}
+        ORDER BY id ASC
+        LIMIT %(limit)s
+    """
+
+    delete_query_person_distinct_ids = f"""
+    WITH to_delete AS ({select_query})
+    DELETE FROM posthog_persondistinctid
+    WHERE team_id = %(team_id)s AND person_id IN (SELECT id FROM to_delete);
+    """
+
+    delete_query_person_override = f"""
+    WITH to_delete AS ({select_query})
+    DELETE FROM posthog_personoverride
+    WHERE team_id = %(team_id)s AND (old_person_id IN (SELECT id FROM to_delete) OR override_person_id IN (SELECT id FROM to_delete));
+    """
+
+    delete_query_person = f"""
+    WITH to_delete AS ({select_query})
+    DELETE FROM posthog_person
+    WHERE team_id = %(team_id)s AND id IN (SELECT id FROM to_delete);
+    """
+
+    with connection.cursor() as cursor:
+        prepared_person_distinct_ids_query = cursor.mogrify(
+            delete_query_person_distinct_ids, {"team_id": team_id, "limit": batch_size, "person_ids": person_ids}
+        )
+        prepared_person_override_query = cursor.mogrify(
+            delete_query_person_override, {"team_id": team_id, "limit": batch_size, "person_ids": person_ids}
+        )
+        prepared_person_query = cursor.mogrify(
+            delete_query_person, {"team_id": team_id, "limit": batch_size, "person_ids": person_ids}
+        )
+
+    logger.info(f"Delete query to run:")
+    logger.info(prepared_person_distinct_ids_query)
+    logger.info(prepared_person_override_query)
+    logger.info(prepared_person_query)
+
+    if not live_run:
+        logger.info(f"Dry run. Set --live-run to actually delete.")
+        return exit(0)
+
+    confirm = input("Type 'delete' to confirm: ")
+
+    if confirm != "delete":
+        logger.info("Aborting")
+        return exit(0)
+
+    logger.info(f"Executing delete query...")
+
+    for i in range(0, batches):
+        logger.info(f"Deleting batch {i + 1} of {batches} ({batch_size} rows)")
+        with connection.cursor() as cursor:
+            cursor.execute(
+                delete_query_person_distinct_ids, {"team_id": team_id, "limit": batch_size, "person_ids": person_ids}
+            )
+            logger.info(f"Deleted {cursor.rowcount} distinct_ids")
+            cursor.execute(
+                delete_query_person_override, {"team_id": team_id, "limit": batch_size, "person_ids": person_ids}
+            )
+            logger.info(f"Deleted {cursor.rowcount} person overrides")
+            cursor.execute(delete_query_person, {"team_id": team_id, "limit": batch_size, "person_ids": person_ids})
+            logger.info(f"Deleted {cursor.rowcount} persons")
+
+            if cursor.rowcount < batch_size:
+                logger.info(f"Exiting early as we received less than {batch_size} rows")
+                break
+
+    logger.info("Done")
diff --git a/posthog/management/commands/generate_demo_data.py b/posthog/management/commands/generate_demo_data.py
index ce094620453a1..dae5cca8ffa73 100644
--- a/posthog/management/commands/generate_demo_data.py
+++ b/posthog/management/commands/generate_demo_data.py
@@ -2,6 +2,7 @@
 import logging
 import secrets
 from time import monotonic
+from typing import Optional
 
 from django.core import exceptions
 from django.core.management.base import BaseCommand
@@ -67,13 +68,13 @@ def handle(self, *args, **options):
         seed = options.get("seed") or secrets.token_hex(16)
         now = options.get("now") or dt.datetime.now(dt.UTC)
         existing_team_id = options.get("team_id")
-        if (
-            existing_team_id is not None
-            and existing_team_id != 0
-            and not Team.objects.filter(pk=existing_team_id).exists()
-        ):
-            print(f"Team with ID {options['team_id']} does not exist!")
-            return
+        existing_team: Optional[Team] = None
+        if existing_team_id is not None and existing_team_id != 0:
+            try:
+                existing_team = Team.objects.get(pk=existing_team_id)
+            except Team.DoesNotExist:
+                print(f"Team with ID {options['team_id']} does not exist!")
+                return
         print("Instantiating the Matrix...")
         matrix = HedgeboxMatrix(
             seed,
@@ -81,8 +82,8 @@ def handle(self, *args, **options):
             days_past=options["days_past"],
             days_future=options["days_future"],
             n_clusters=options["n_clusters"],
-            group_type_index_offset=GroupTypeMapping.objects.filter(team_id=existing_team_id).count()
-            if existing_team_id
+            group_type_index_offset=GroupTypeMapping.objects.filter(project_id=existing_team.project_id).count()
+            if existing_team
             else 0,
         )
         print("Running simulation...")
diff --git a/posthog/management/commands/migrate_action_webhooks.py b/posthog/management/commands/migrate_action_webhooks.py
index c35a90f61232b..6dd92d53ad682 100644
--- a/posthog/management/commands/migrate_action_webhooks.py
+++ b/posthog/management/commands/migrate_action_webhooks.py
@@ -140,7 +140,7 @@ def convert_to_hog_function(action: Action, inert=False) -> Optional[HogFunction
         inputs_schema=webhook_template.inputs_schema,
         template_id=webhook_template.id,
         hog=hog_code,
-        bytecode=compile_hog(hog_code),
+        bytecode=compile_hog(hog_code, "destination"),
         filters=compile_filters_bytecode(
             {"actions": [{"id": f"{action.id}", "type": "actions", "name": action.name, "order": 0}]}, action.team
         ),
diff --git a/posthog/management/commands/sync_feature_flags.py b/posthog/management/commands/sync_feature_flags.py
index 4e26061603691..22390a90f04e8 100644
--- a/posthog/management/commands/sync_feature_flags.py
+++ b/posthog/management/commands/sync_feature_flags.py
@@ -2,7 +2,7 @@
 
 from django.core.management.base import BaseCommand
 
-from posthog.models import FeatureFlag, Team, User
+from posthog.models import FeatureFlag, Project, User
 
 INACTIVE_FLAGS = [
     "cloud-announcement",
@@ -12,7 +12,7 @@
 
 
 class Command(BaseCommand):
-    help = "Add and enable all feature flags in frontend/src/lib/constants.tsx for all teams"
+    help = "Add and enable all feature flags in frontend/src/lib/constants.tsx for all projects"
 
     def handle(self, *args, **options):
         flags: dict[str, str] = {}
@@ -37,23 +37,27 @@ def handle(self, *args, **options):
                     parsing_flags = True
 
         first_user = cast(User, User.objects.first())
-        for team in Team.objects.all():
-            existing_flags = FeatureFlag.objects.filter(team=team).values_list("key", flat=True)
-            deleted_flags = FeatureFlag.objects.filter(team=team, deleted=True).values_list("key", flat=True)
+        for project in Project.objects.all():
+            existing_flags = FeatureFlag.objects.filter(team__project_id=project.id).values_list("key", flat=True)
+            deleted_flags = FeatureFlag.objects.filter(team__project_id=project.id, deleted=True).values_list(
+                "key", flat=True
+            )
             for flag in flags.keys():
                 flag_type = flags[flag]
                 is_enabled = flag not in INACTIVE_FLAGS
 
                 if flag in deleted_flags:
-                    ff = FeatureFlag.objects.filter(team=team, key=flag)[0]
+                    ff = FeatureFlag.objects.filter(team__project_id=project.id, key=flag)[0]
                     ff.deleted = False
                     ff.active = is_enabled
                     ff.save()
-                    print(f"Undeleted feature flag '{flag} for team {team.id} {' - ' + team.name if team.name else ''}")
+                    print(
+                        f"Undeleted feature flag '{flag} for project {project.id} {' - ' + project.name if project.name else ''}"
+                    )
                 elif flag not in existing_flags:
                     if flag_type == "multivariate":
                         FeatureFlag.objects.create(
-                            team=team,
+                            team=project.teams.first(),
                             rollout_percentage=100,
                             name=flag,
                             key=flag,
@@ -79,11 +83,13 @@ def handle(self, *args, **options):
                         )
                     else:
                         FeatureFlag.objects.create(
-                            team=team,
+                            team=project.teams.first(),
                             rollout_percentage=100,
                             name=flag,
                             key=flag,
                             created_by=first_user,
                             active=is_enabled,
                         )
-                    print(f"Created feature flag '{flag} for team {team.id} {' - ' + team.name if team.name else ''}")
+                    print(
+                        f"Created feature flag '{flag} for project {project.id} {' - ' + project.name if project.name else ''}"
+                    )
diff --git a/posthog/management/commands/sync_remote_configs.py b/posthog/management/commands/sync_remote_configs.py
new file mode 100644
index 0000000000000..5b8944f370d9a
--- /dev/null
+++ b/posthog/management/commands/sync_remote_configs.py
@@ -0,0 +1,12 @@
+from django.core.management.base import BaseCommand
+
+from posthog.tasks.remote_config import sync_all_remote_configs
+
+
+class Command(BaseCommand):
+    help = "Sync all RemoteConfigs"
+
+    def handle(self, *args, **options):
+        print("Syncing RemoteConfigs for all teams...")  # noqa: T201
+        sync_all_remote_configs()
+        print("All syncs scheduled")  # noqa: T201
diff --git a/posthog/management/commands/warehouse_last_incremental_value_sync.py b/posthog/management/commands/warehouse_last_incremental_value_sync.py
new file mode 100644
index 0000000000000..0c610d92164de
--- /dev/null
+++ b/posthog/management/commands/warehouse_last_incremental_value_sync.py
@@ -0,0 +1,143 @@
+from typing import Any, Optional
+from django.core.management.base import BaseCommand
+from django.conf import settings
+
+import dlt
+import dlt.common
+import dlt.common.pipeline
+import dlt.common.configuration.resolve
+
+from dlt.common.configuration.specs.base_configuration import (
+    is_secret_hint,
+)
+from dlt.common.configuration.providers.provider import ConfigProvider
+from dlt.common.configuration.exceptions import (
+    LookupTrace,
+    ValueNotSecretException,
+)
+
+from posthog.warehouse.models.external_data_schema import ExternalDataSchema
+
+
+# Redefine a broken DLT func
+def _resolve_single_provider_value(
+    provider: ConfigProvider,
+    key: str,
+    hint: type[Any],
+    pipeline_name: str | None = None,  # type: ignore
+    config_section: str | None = None,  # type: ignore
+    explicit_sections: tuple[str, ...] = (),
+    embedded_sections: tuple[str, ...] = (),
+) -> tuple[Optional[Any], list[LookupTrace]]:
+    traces: list[LookupTrace] = []
+
+    if provider.supports_sections:
+        ns = list(explicit_sections if explicit_sections is not None else ())  # This was the broken line
+        # always extend with embedded sections
+        ns.extend(embedded_sections)
+    else:
+        # if provider does not support sections and pipeline name is set then ignore it
+        if pipeline_name:
+            return None, traces
+        else:
+            # pass empty sections
+            ns = []
+
+    value = None
+    while True:
+        if config_section and provider.supports_sections:
+            full_ns = ns.copy()
+            # config section, is always present and innermost
+            if config_section:
+                full_ns.append(config_section)
+        else:
+            full_ns = ns
+        value, ns_key = provider.get_value(key, hint, pipeline_name, *full_ns)
+        # if secret is obtained from non secret provider, we must fail
+        cant_hold_it: bool = not provider.supports_secrets and is_secret_hint(hint)
+        if value is not None and cant_hold_it:
+            raise ValueNotSecretException(provider.name, ns_key)
+
+        # create trace, ignore providers that cant_hold_it
+        if not cant_hold_it:
+            traces.append(LookupTrace(provider.name, full_ns, ns_key, value))
+
+        if value is not None:
+            # value found, ignore further sections
+            break
+        if len(ns) == 0:
+            # sections exhausted
+            break
+        # pop optional sections for less precise lookup
+        ns.pop()
+
+    return value, traces
+
+
+dlt.common.configuration.resolve.resolve_single_provider_value = _resolve_single_provider_value
+
+
+class Command(BaseCommand):
+    help = "Sync Data Warehouse last incremental values from DLT S3"
+
+    def handle(self, *args, **options):
+        destination = dlt.destinations.filesystem(
+            credentials={
+                "aws_access_key_id": settings.AIRBYTE_BUCKET_KEY,
+                "aws_secret_access_key": settings.AIRBYTE_BUCKET_SECRET,
+                "region_name": settings.AIRBYTE_BUCKET_REGION,
+                "AWS_DEFAULT_REGION": settings.AIRBYTE_BUCKET_REGION,
+                "AWS_S3_ALLOW_UNSAFE_RENAME": "true",
+            },
+            bucket_url=str(settings.BUCKET_URL),
+        )
+
+        schemas = (
+            ExternalDataSchema.objects.filter(sync_type="incremental", deleted=False)
+            .exclude(sync_type_config__has_key="incremental_field_last_value")
+            .select_related("source")
+        )
+
+        total_schemas = len(schemas)
+        print(f"Total schemas: {total_schemas}")  # noqa: T201
+
+        for index, schema in enumerate(schemas):
+            print(f"Updating schema {index + 1}/{total_schemas} - Schema.ID: {schema.pk}")  # noqa: T201
+
+            dataset_name = schema.folder_path()
+            team_id = schema.team_id
+            schema_id = str(schema.id)
+            job_type = schema.source.source_type
+            pipeline_name = f"{job_type}_pipeline_{team_id}_run_{schema_id}"
+
+            pipeline = dlt.pipeline(
+                pipeline_name=pipeline_name,
+                destination=destination,
+                dataset_name=dataset_name,
+            )
+
+            pipeline.sync_destination()
+
+            try:
+                sources = pipeline.state["sources"]  # type: ignore
+                resource = sources[next(iter(sources.keys()))]
+                resources = resource["resources"]
+                tables = resources[next(iter(resources.keys()))]
+                table = tables[next(iter(tables.keys()))]
+                incremental = table[next(iter(table.keys()))]
+                last_incremental_value = incremental.get("last_value")
+            except Exception as e:
+                print(f"Cant get last_incremental_value for schema: {schema.pk}. ERROR: {e}")  # noqa: T201
+                pipeline.drop()
+                continue
+
+            try:
+                schema.update_incremental_field_last_value(last_incremental_value)
+            except Exception as e:
+                print(  # noqa: T201
+                    f"Cant update_incremental_field_last_value for schema: {schema.pk}. With last_incremental_value={last_incremental_value}. ERROR: {e}"
+                )
+                pipeline.drop()
+                continue
+
+            pipeline.drop()
diff --git a/posthog/middleware.py b/posthog/middleware.py
index ee132dc78d0af..af7b6768d9c54 100644
--- a/posthog/middleware.py
+++ b/posthog/middleware.py
@@ -677,7 +677,19 @@ def get_impersonated_session_expires_at(request: HttpRequest) -> Optional[dateti
 
     init_time = get_or_set_session_cookie_created_at(request=request)
 
-    return datetime.fromtimestamp(init_time) + timedelta(seconds=settings.IMPERSONATION_TIMEOUT_SECONDS)
+    last_activity_time = request.session.get(settings.IMPERSONATION_COOKIE_LAST_ACTIVITY_KEY, init_time)
+
+    # If the last activity time is less than the idle timeout, we extend the session
+    if time.time() - last_activity_time < settings.IMPERSONATION_IDLE_TIMEOUT_SECONDS:
+        last_activity_time = request.session[settings.IMPERSONATION_COOKIE_LAST_ACTIVITY_KEY] = time.time()
+        request.session.modified = True
+
+    idle_expiry_time = datetime.fromtimestamp(last_activity_time) + timedelta(
+        seconds=settings.IMPERSONATION_IDLE_TIMEOUT_SECONDS
+    )
+    total_expiry_time = datetime.fromtimestamp(init_time) + timedelta(seconds=settings.IMPERSONATION_TIMEOUT_SECONDS)
+
+    return min(idle_expiry_time, total_expiry_time)
 
 
 class AutoLogoutImpersonateMiddleware:
diff --git a/posthog/migrations/0526_remoteconfig.py b/posthog/migrations/0526_remoteconfig.py
new file mode 100644
index 0000000000000..cfd27ed26c2b0
--- /dev/null
+++ b/posthog/migrations/0526_remoteconfig.py
@@ -0,0 +1,32 @@
+# Generated by Django 4.2.15 on 2024-11-29 16:21
+
+from django.db import migrations, models
+import django.db.models.deletion
+import posthog.models.utils
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("posthog", "0525_hog_function_transpiled"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="RemoteConfig",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=posthog.models.utils.UUIDT, editable=False, primary_key=True, serialize=False
+                    ),
+                ),
+                ("config", models.JSONField()),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                ("synced_at", models.DateTimeField(null=True)),
+                ("team", models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to="posthog.team")),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+    ]
diff --git a/posthog/migrations/0527_project_name_sync.py b/posthog/migrations/0527_project_name_sync.py
new file mode 100644
index 0000000000000..23c29ffe82fb1
--- /dev/null
+++ b/posthog/migrations/0527_project_name_sync.py
@@ -0,0 +1,19 @@
+# Created manually
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [("posthog", "0526_remoteconfig")]
+
+    operations = [
+        migrations.RunSQL(
+            """
+            UPDATE posthog_project AS proj
+            SET name = team.name
+            FROM posthog_team AS team
+            WHERE proj.id = team.project_id AND proj.name != team.name""",
+            reverse_sql=migrations.RunSQL.noop,
+            elidable=True,
+        ),
+    ]
diff --git a/posthog/migrations/0528_project_field_in_taxonomy.py b/posthog/migrations/0528_project_field_in_taxonomy.py
new file mode 100644
index 0000000000000..a410d85a9e53b
--- /dev/null
+++ b/posthog/migrations/0528_project_field_in_taxonomy.py
@@ -0,0 +1,89 @@
+# Generated by Django 4.2.15 on 2024-10-29 12:15
+
+from django.db import migrations, models
+import django.db.models.deletion
+from django.contrib.postgres.operations import AddIndexConcurrently
+from django.db.models.expressions import F, OrderBy
+from django.db.models.functions.comparison import Coalesce
+
+
+class Migration(migrations.Migration):
+    atomic = False  # Added to support concurrent index creation
+    dependencies = [("posthog", "0527_project_name_sync")]
+
+    operations = [
+        migrations.RunSQL(
+            """
+            -- Add field project to eventdefinition
+            ALTER TABLE "posthog_eventdefinition" ADD COLUMN "project_id" bigint NULL CONSTRAINT "posthog_eventdefinit_project_id_f93fcbb0_fk_posthog_p" REFERENCES "posthog_project"("id") DEFERRABLE INITIALLY DEFERRED;
+            SET CONSTRAINTS "posthog_eventdefinit_project_id_f93fcbb0_fk_posthog_p" IMMEDIATE;
+            -- Add field project to eventproperty
+            ALTER TABLE "posthog_eventproperty" ADD COLUMN "project_id" bigint NULL CONSTRAINT "posthog_eventproperty_project_id_dd2337d2_fk_posthog_project_id" REFERENCES "posthog_project"("id") DEFERRABLE INITIALLY DEFERRED;
+            SET CONSTRAINTS "posthog_eventproperty_project_id_dd2337d2_fk_posthog_project_id" IMMEDIATE;
+            -- Add field project to propertydefinition
+            ALTER TABLE "posthog_propertydefinition" ADD COLUMN "project_id" bigint NULL CONSTRAINT "posthog_propertydefi_project_id_d3eb982d_fk_posthog_p" REFERENCES "posthog_project"("id") DEFERRABLE INITIALLY DEFERRED;
+            SET CONSTRAINTS "posthog_propertydefi_project_id_d3eb982d_fk_posthog_p" IMMEDIATE;""",
+            reverse_sql="""
+            ALTER TABLE "posthog_eventdefinition" DROP COLUMN IF EXISTS "project_id";
+            ALTER TABLE "posthog_eventproperty" DROP COLUMN IF EXISTS "project_id";
+            ALTER TABLE "posthog_propertydefinition" DROP COLUMN IF EXISTS "project_id";""",
+            state_operations=[
+                migrations.AddField(
+                    model_name="eventdefinition",
+                    name="project",
+                    field=models.ForeignKey(
+                        null=True, on_delete=django.db.models.deletion.CASCADE, to="posthog.project"
+                    ),
+                ),
+                migrations.AddField(
+                    model_name="eventproperty",
+                    name="project",
+                    field=models.ForeignKey(
+                        null=True, on_delete=django.db.models.deletion.CASCADE, to="posthog.project"
+                    ),
+                ),
+                migrations.AddField(
+                    model_name="propertydefinition",
+                    name="project",
+                    field=models.ForeignKey(
+                        null=True, on_delete=django.db.models.deletion.CASCADE, to="posthog.project"
+                    ),
+                ),
+            ],
+        ),
+        AddIndexConcurrently(
+            model_name="eventdefinition",
+            index=models.Index(fields=["project"], name="posthog_eve_proj_id_f93fcbb0"),
+        ),
+        AddIndexConcurrently(
+            model_name="propertydefinition",
+            index=models.Index(fields=["project"], name="posthog_prop_proj_id_d3eb982d"),
+        ),
+        AddIndexConcurrently(
+            model_name="propertydefinition",
+            index=models.Index(
+                F("project_id"),
+                F("type"),
+                Coalesce(F("group_type_index"), -1),
+                OrderBy(F("query_usage_30_day"), descending=True, nulls_last=True),
+                OrderBy(F("name")),
+                name="index_property_def_query_proj",
+            ),
+        ),
+        AddIndexConcurrently(
+            model_name="propertydefinition",
+            index=models.Index(fields=["project_id", "type", "is_numerical"], name="posthog_pro_project_3583d2_idx"),
+        ),
+        AddIndexConcurrently(
+            model_name="eventproperty",
+            index=models.Index(fields=["project"], name="posthog_eve_proj_id_dd2337d2"),
+        ),
+        AddIndexConcurrently(
+            model_name="eventproperty",
+            index=models.Index(fields=["project", "event"], name="posthog_eve_proj_id_22de03_idx"),
+        ),
+        AddIndexConcurrently(
+            model_name="eventproperty",
+            index=models.Index(fields=["project", "property"], name="posthog_eve_proj_id_26dbfb_idx"),
+        ),
+    ]
diff --git a/posthog/migrations/0529_hog_function_mappings.py b/posthog/migrations/0529_hog_function_mappings.py
new file mode 100644
index 0000000000000..a15735cc89290
--- /dev/null
+++ b/posthog/migrations/0529_hog_function_mappings.py
@@ -0,0 +1,17 @@
+# Generated by Django 4.2.15 on 2024-12-10 11:36
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("posthog", "0528_project_field_in_taxonomy"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="hogfunction",
+            name="mappings",
+            field=models.JSONField(blank=True, null=True),
+        ),
+    ]
diff --git a/posthog/migrations/0530_convert_dashboard_templates_to_queries.py b/posthog/migrations/0530_convert_dashboard_templates_to_queries.py
new file mode 100644
index 0000000000000..393032d32a1ca
--- /dev/null
+++ b/posthog/migrations/0530_convert_dashboard_templates_to_queries.py
@@ -0,0 +1,31 @@
+# Generated by Django 4.2.15 on 2024-11-04 11:24
+
+from django.db import migrations
+
+from posthog.hogql_queries.legacy_compatibility.filter_to_query import filter_to_query
+from posthog.schema import InsightVizNode
+
+
+def update_filters_to_queries(apps, schema_editor):
+    DashboardTemplate = apps.get_model("posthog", "DashboardTemplate")
+
+    for template in DashboardTemplate.objects.all():
+        for tile in template.tiles:
+            if "filters" in tile:
+                source = filter_to_query(tile["filters"], allow_variables=True)
+                query = InsightVizNode(source=source)
+                tile["query"] = query.model_dump(exclude_none=True)
+                del tile["filters"]
+        template.save()
+
+
+def revert_queries_to_filters(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [("posthog", "0529_hog_function_mappings")]
+
+    operations = [
+        migrations.RunPython(update_filters_to_queries, revert_queries_to_filters),
+    ]
diff --git a/posthog/migrations/0531_alter_hogfunction_type.py b/posthog/migrations/0531_alter_hogfunction_type.py
new file mode 100644
index 0000000000000..b3160bc5fbc2d
--- /dev/null
+++ b/posthog/migrations/0531_alter_hogfunction_type.py
@@ -0,0 +1,33 @@
+# Generated by Django 4.2.15 on 2024-12-13 13:22
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("posthog", "0530_convert_dashboard_templates_to_queries"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="hogfunction",
+            name="type",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("destination", "Destination"),
+                    ("site_destination", "Site Destination"),
+                    ("site_app", "Site App"),
+                    ("transformation", "Transformation"),
+                    ("email", "Email"),
+                    ("sms", "Sms"),
+                    ("push", "Push"),
+                    ("activity", "Activity"),
+                    ("alert", "Alert"),
+                    ("broadcast", "Broadcast"),
+                ],
+                max_length=24,
+                null=True,
+            ),
+        ),
+    ]
diff --git a/posthog/migrations/0532_taxonomy_unique_on_project.py b/posthog/migrations/0532_taxonomy_unique_on_project.py
new file mode 100644
index 0000000000000..2ba5b98d2652c
--- /dev/null
+++ b/posthog/migrations/0532_taxonomy_unique_on_project.py
@@ -0,0 +1,119 @@
+# Generated by Django 4.2.15 on 2024-12-09 15:51
+
+from django.db import migrations
+from django.db import models
+import django.db.models.functions.comparison
+import posthog.models.utils
+from django.contrib.postgres.operations import AddIndexConcurrently, RemoveIndexConcurrently
+
+
+class Migration(migrations.Migration):
+    atomic = False  # Added to support concurrent index creation
+    dependencies = [("posthog", "0531_alter_hogfunction_type")]
+
+    operations = [
+        # First clean up rows that would fail the project-based unique constraints we're adding
+        migrations.RunSQL(
+            sql="""
+            DELETE FROM posthog_propertydefinition
+            WHERE team_id IN (
+                SELECT id FROM posthog_team WHERE id != project_id
+            );""",
+            reverse_sql=migrations.RunSQL.noop,
+            elidable=True,
+        ),
+        migrations.RunSQL(
+            sql="""
+            DELETE FROM posthog_eventdefinition
+            WHERE team_id IN (
+                SELECT id FROM posthog_team WHERE id != project_id
+            );""",
+            reverse_sql=migrations.RunSQL.noop,
+            elidable=True,
+        ),
+        migrations.RunSQL(
+            sql="""
+            DELETE FROM posthog_eventproperty
+            WHERE team_id IN (
+                SELECT id FROM posthog_team WHERE id != project_id
+            );""",
+            reverse_sql=migrations.RunSQL.noop,
+            elidable=True,
+        ),
+        # Remove misguided `project_id`-only indexes from the previous migration
+        RemoveIndexConcurrently(
+            model_name="eventproperty",
+            name="posthog_eve_proj_id_22de03_idx",
+        ),
+        RemoveIndexConcurrently(
+            model_name="eventproperty",
+            name="posthog_eve_proj_id_26dbfb_idx",
+        ),
+        RemoveIndexConcurrently(
+            model_name="propertydefinition",
+            name="index_property_def_query_proj",
+        ),
+        RemoveIndexConcurrently(
+            model_name="propertydefinition",
+            name="posthog_pro_project_3583d2_idx",
+        ),
+        # Add new useful indexes using `coalesce(project_id, team_id)`
+        AddIndexConcurrently(
+            model_name="eventproperty",
+            index=models.Index(
+                django.db.models.functions.comparison.Coalesce(models.F("project_id"), models.F("team_id")),
+                models.F("event"),
+                name="posthog_eve_proj_id_22de03_idx",
+            ),
+        ),
+        AddIndexConcurrently(
+            model_name="eventproperty",
+            index=models.Index(
+                django.db.models.functions.comparison.Coalesce(models.F("project_id"), models.F("team_id")),
+                models.F("property"),
+                name="posthog_eve_proj_id_26dbfb_idx",
+            ),
+        ),
+        AddIndexConcurrently(
+            model_name="propertydefinition",
+            index=models.Index(
+                django.db.models.functions.comparison.Coalesce(models.F("project_id"), models.F("team_id")),
+                models.F("type"),
+                django.db.models.functions.comparison.Coalesce(models.F("group_type_index"), -1),
+                models.OrderBy(models.F("query_usage_30_day"), descending=True, nulls_last=True),
+                models.OrderBy(models.F("name")),
+                name="index_property_def_query_proj",
+            ),
+        ),
+        AddIndexConcurrently(
+            model_name="propertydefinition",
+            index=models.Index(
+                django.db.models.functions.comparison.Coalesce(models.F("project_id"), models.F("team_id")),
+                models.F("type"),
+                models.F("is_numerical"),
+                name="posthog_pro_project_3583d2_idx",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="eventdefinition",
+            constraint=posthog.models.utils.UniqueConstraintByExpression(
+                concurrently=True, expression="(coalesce(project_id, team_id), name)", name="event_definition_proj_uniq"
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="eventproperty",
+            constraint=posthog.models.utils.UniqueConstraintByExpression(
+                concurrently=True,
+                expression="(coalesce(project_id, team_id), event, property)",
+                name="posthog_event_property_unique_proj_event_property",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="propertydefinition",
+            constraint=posthog.models.utils.UniqueConstraintByExpression(
+                concurrently=True,
+                expression="(coalesce(project_id, team_id), name, type, coalesce(group_type_index, -1))",
+                name="posthog_propdef_proj_uniq",
+            ),
+        ),
+    ]
diff --git a/posthog/migrations/max_migration.txt b/posthog/migrations/max_migration.txt
index 85a418de0b4c1..01fc03d62a8a0 100644
--- a/posthog/migrations/max_migration.txt
+++ b/posthog/migrations/max_migration.txt
@@ -1 +1 @@
-0525_hog_function_transpiled
+0532_taxonomy_unique_on_project
diff --git a/posthog/models/__init__.py b/posthog/models/__init__.py
index fca47f33d53ea..593d60f95934f 100644
--- a/posthog/models/__init__.py
+++ b/posthog/models/__init__.py
@@ -30,7 +30,12 @@
 from .element import Element
 from .element_group import ElementGroup
 from .entity import Entity
-from .error_tracking import ErrorTrackingIssue, ErrorTrackingStackFrame, ErrorTrackingSymbolSet
+from .error_tracking import (
+    ErrorTrackingIssue,
+    ErrorTrackingIssueFingerprintV2,
+    ErrorTrackingStackFrame,
+    ErrorTrackingSymbolSet,
+)
 from .event.event import Event
 from .event_buffer import EventBuffer
 from .event_definition import EventDefinition
@@ -67,6 +72,7 @@
 from .property import Property
 from .property_definition import PropertyDefinition
 from .proxy_record import ProxyRecord
+from .remote_config import RemoteConfig
 from .scheduled_change import ScheduledChange
 from .sharing_configuration import SharingConfiguration
 from .subscription import Subscription
@@ -102,6 +108,7 @@
     "ElementGroup",
     "Entity",
     "ErrorTrackingIssue",
+    "ErrorTrackingIssueFingerprintV2",
     "ErrorTrackingStackFrame",
     "ErrorTrackingSymbolSet",
     "Event",
@@ -146,6 +153,7 @@
     "PropertyDefinition",
     "ProxyRecord",
     "RetentionFilter",
+    "RemoteConfig",
     "SessionRecording",
     "SessionRecordingPlaylist",
     "SessionRecordingPlaylistItem",
diff --git a/posthog/models/channel_type/channel_definitions.json b/posthog/models/channel_type/channel_definitions.json
index 9c0e31e46743b..3558859cd81af 100644
--- a/posthog/models/channel_type/channel_definitions.json
+++ b/posthog/models/channel_type/channel_definitions.json
@@ -47,6 +47,7 @@
     ["com.alibaba.intl.android.apps.poseidon", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
     ["com.alibaba.intl.android.apps.twa", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
     ["com.alibaba.sourcing", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
+    ["com.alibaba.sourcing.ent", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
     ["m.alibaba.com", "source", "Shopping", "Paid Shopping", "Organic Shopping", false],
     ["message.alibaba.com", "source", "Shopping", "Paid Shopping", "Organic Shopping", false],
     ["offer.alibaba.com", "source", "Shopping", "Paid Shopping", "Organic Shopping", false],
@@ -62,6 +63,8 @@
     ["amazon.co.uk", "source", "Shopping", "Paid Shopping", "Organic Shopping", false],
     ["amazon.com", "source", "Shopping", "Paid Shopping", "Organic Shopping", false],
     ["com.amazon.avod.thirdpartyclient", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
+    ["com.amazon.kindle", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
+    ["com.amazon.kindlefs", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
     ["com.amazon.mp3", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
     ["com.amazon.mshop.android.business.shopping", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
     ["com.amazon.mshop.android.shopping", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
@@ -100,6 +103,11 @@
     ["askubuntu", "source", "Social", "Paid Social", "Organic Social", false],
     ["askubuntu.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["asmallworld.com", "source", "Social", "Paid Social", "Organic Social", false],
+    ["com.asmallworld.android", "source", "Social", "Paid Social", "Organic Social", true],
+    ["com.asmallworld.android_europa", "source", "Social", "Paid Social", "Organic Social", true],
+    ["com.asmallworld.android_ganymede", "source", "Social", "Paid Social", "Organic Social", true],
+    ["com.asmallworld.android_io", "source", "Social", "Paid Social", "Organic Social", true],
+    ["net.asmallworld.ios", "source", "Social", "Paid Social", "Organic Social", true],
     ["com.atebits.tweetie2", "source", "Social", "Paid Social", "Organic Social", true],
     ["athlinks", "source", "Social", "Paid Social", "Organic Social", false],
     ["athlinks.com", "source", "Social", "Paid Social", "Organic Social", false],
@@ -130,6 +138,7 @@
     ["bebo.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["beforeitsnews", "source", "Social", "Paid Social", "Organic Social", false],
     ["beforeitsnews.com", "source", "Social", "Paid Social", "Organic Social", false],
+    ["ru.beru.android", "source", "Search", "Paid Search", "Organic Search", true],
     ["bharatstudent", "source", "Social", "Paid Social", "Organic Social", false],
     ["bharatstudent.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["biglobe", "source", "Search", "Paid Search", "Organic Search", false],
@@ -314,6 +323,8 @@
     ["epicurious.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["etsy", "source", "Shopping", "Paid Shopping", "Organic Shopping", false],
     ["com.etsy.android", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
+    ["com.etsy.butter.sell_on_etsy", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
+    ["com.etsy.butter.sell_on_etsy.enterprise", "source", "Shopping", "Paid Shopping", "Organic Shopping", true],
     ["etsy.com", "source", "Shopping", "Paid Shopping", "Organic Shopping", false],
     ["everforo.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["exalead.com", "source", "Search", "Paid Search", "Organic Search", false],
@@ -341,6 +352,7 @@
     ["com.facebook.pages.app", "source", "Social", "Paid Social", "Organic Social", true],
     ["com.facebook.scenes", "source", "Social", "Paid Social", "Organic Social", true],
     ["com.facebook.shoerack", "source", "Social", "Paid Social", "Organic Social", true],
+    ["com.facebook.stella", "source", "Social", "Paid Social", "Organic Social", true],
     ["com.facebook.stellaapp", "source", "Social", "Paid Social", "Organic Social", true],
     ["com.facebook.stellaapp.master", "source", "Social", "Paid Social", "Organic Social", true],
     ["com.facebook.wakizashi", "source", "Social", "Paid Social", "Organic Social", true],
@@ -925,10 +937,12 @@
     ["ning.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["com.oath.yahooapp", "source", "Social", "Paid Social", "Organic Social", true],
     ["com.oculus.facebook", "source", "Social", "Paid Social", "Organic Social", true],
+    ["com.oculus.igvr", "source", "Social", "Paid Social", "Organic Social", true],
     ["odnoklassniki.ru", "source", "Social", "Paid Social", "Organic Social", false],
     ["ru.odnoklassniki.iphone", "source", "Social", "Paid Social", "Organic Social", true],
     ["odnoklassniki.ua", "source", "Social", "Paid Social", "Organic Social", false],
     ["ru.ok.android", "source", "Social", "Paid Social", "Organic Social", true],
+    ["ru.ok.dating", "source", "Social", "Paid Social", "Organic Social", true],
     ["ru.ok.live", "source", "Social", "Paid Social", "Organic Social", true],
     ["okwave.jp", "source", "Social", "Paid Social", "Organic Social", false],
     ["onesearch.com", "source", "Search", "Paid Search", "Organic Search", false],
@@ -1350,6 +1364,7 @@
     ["org.wordpress.android", "source", "Social", "Paid Social", "Organic Social", true],
     ["wordpress.org", "source", "Social", "Paid Social", "Organic Social", false],
     ["forums.wpcentral.com", "source", "Social", "Paid Social", "Organic Social", false],
+    ["x.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["xanga", "source", "Social", "Paid Social", "Organic Social", false],
     ["xanga.com", "source", "Social", "Paid Social", "Organic Social", false],
     ["xing", "source", "Social", "Paid Social", "Organic Social", false],
@@ -1457,6 +1472,7 @@
     ["ru.yandex.mobile.yamb", "source", "Search", "Paid Search", "Organic Search", true],
     ["ru.yandex.mobile.zen", "source", "Search", "Paid Search", "Organic Search", true],
     ["ru.yandex.mobile.zen-enterprise", "source", "Search", "Paid Search", "Organic Search", true],
+    ["ru.yandex.music", "source", "Search", "Paid Search", "Organic Search", true],
     ["ru.yandex.rhythm", "source", "Search", "Paid Search", "Organic Search", true],
     ["ru.yandex.searchplugin", "source", "Search", "Paid Search", "Organic Search", true],
     ["ru.yandex.taxi", "source", "Search", "Paid Search", "Organic Search", true],
diff --git a/posthog/models/cohort/cohort.py b/posthog/models/cohort/cohort.py
index 1ab980bfc6796..f658bbd07e6de 100644
--- a/posthog/models/cohort/cohort.py
+++ b/posthog/models/cohort/cohort.py
@@ -250,11 +250,16 @@ def calculate_people_ch(self, pending_version: int, *, initiating_user_id: Optio
 
         clear_stale_cohort.delay(self.pk, before_version=pending_version)
 
-    def insert_users_by_list(self, items: list[str]) -> None:
-        """
-        Items is a list of distinct_ids
+    def insert_users_by_list(self, items: list[str], *, team_id: Optional[int] = None) -> None:
         """
+        Insert a list of users identified by their distinct ID into the cohort, for the given team.
 
+        Args:
+            items: List of distinct IDs of users to be inserted into the cohort.
+            team_id: ID of the team for which to insert the users. Defaults to `self.team`, because of a lot of existing usage in tests.
+        """
+        if team_id is None:
+            team_id = self.team_id
         batchsize = 1000
         from posthog.models.cohort.util import (
             insert_static_cohort,
@@ -272,10 +277,10 @@ def insert_users_by_list(self, items: list[str]) -> None:
             for i in range(0, len(items), batchsize):
                 batch = items[i : i + batchsize]
                 persons_query = (
-                    Person.objects.filter(team_id=self.team_id)
+                    Person.objects.filter(team_id=team_id)
                     .filter(
                         Q(
-                            persondistinctid__team_id=self.team_id,
+                            persondistinctid__team_id=team_id,
                             persondistinctid__distinct_id__in=batch,
                         )
                     )
@@ -284,7 +289,7 @@ def insert_users_by_list(self, items: list[str]) -> None:
                 insert_static_cohort(
                     list(persons_query.values_list("uuid", flat=True)),
                     self.pk,
-                    self.team,
+                    team_id=team_id,
                 )
                 sql, params = persons_query.distinct("pk").only("pk").query.sql_with_params()
                 query = UPDATE_QUERY.format(
@@ -297,7 +302,7 @@ def insert_users_by_list(self, items: list[str]) -> None:
                 )
                 cursor.execute(query, params)
 
-            count = get_static_cohort_size(self)
+            count = get_static_cohort_size(cohort_id=self.id, team_id=self.team_id)
             self.count = count
 
             self.is_calculating = False
@@ -313,7 +318,18 @@ def insert_users_by_list(self, items: list[str]) -> None:
             self.save()
             capture_exception(err)
 
-    def insert_users_list_by_uuid(self, items: list[str], insert_in_clickhouse: bool = False, batchsize=1000) -> None:
+    def insert_users_list_by_uuid(
+        self, items: list[str], insert_in_clickhouse: bool = False, batchsize=1000, *, team_id: int
+    ) -> None:
+        """
+        Insert a list of users identified by their UUID into the cohort, for the given team.
+
+        Args:
+            items: List of user UUIDs to be inserted into the cohort.
+            insert_in_clickhouse: Whether the data should also be inserted into ClickHouse.
+            batchsize: Number of UUIDs to process in each batch.
+            team_id: The ID of the team to which the cohort belongs.
+        """
         from posthog.models.cohort.util import get_static_cohort_size, insert_static_cohort
 
         try:
@@ -321,13 +337,13 @@ def insert_users_list_by_uuid(self, items: list[str], insert_in_clickhouse: bool
             for i in range(0, len(items), batchsize):
                 batch = items[i : i + batchsize]
                 persons_query = (
-                    Person.objects.filter(team_id=self.team_id).filter(uuid__in=batch).exclude(cohort__id=self.id)
+                    Person.objects.filter(team_id=team_id).filter(uuid__in=batch).exclude(cohort__id=self.id)
                 )
                 if insert_in_clickhouse:
                     insert_static_cohort(
                         list(persons_query.values_list("uuid", flat=True)),
                         self.pk,
-                        self.team,
+                        team_id=team_id,
                     )
                 sql, params = persons_query.distinct("pk").only("pk").query.sql_with_params()
                 query = UPDATE_QUERY.format(
@@ -340,7 +356,7 @@ def insert_users_list_by_uuid(self, items: list[str], insert_in_clickhouse: bool
                 )
                 cursor.execute(query, params)
 
-            count = get_static_cohort_size(self)
+            count = get_static_cohort_size(cohort_id=self.id, team_id=self.team_id)
             self.count = count
 
             self.is_calculating = False
@@ -357,12 +373,6 @@ def insert_users_list_by_uuid(self, items: list[str], insert_in_clickhouse: bool
             self.save()
             capture_exception(err)
 
-    def _clickhouse_persons_query(self, batch_size=10000, offset=0):
-        from posthog.models.cohort.util import get_person_ids_by_cohort_id
-
-        uuids = get_person_ids_by_cohort_id(team=self.team, cohort_id=self.pk, limit=batch_size, offset=offset)
-        return Person.objects.filter(uuid__in=uuids, team=self.team)
-
     __repr__ = sane_repr("id", "name", "last_calculation")
 
 
diff --git a/posthog/models/cohort/sql.py b/posthog/models/cohort/sql.py
index a84394bae94a8..603f8addf08a2 100644
--- a/posthog/models/cohort/sql.py
+++ b/posthog/models/cohort/sql.py
@@ -91,6 +91,8 @@
 """
 
 STALE_COHORTPEOPLE = f"""
-SELECT count() FROM cohortpeople
-WHERE team_id = %(team_id)s AND cohort_id = %(cohort_id)s AND version < %(version)s
+SELECT team_id, count() AS stale_people_count FROM cohortpeople
+WHERE team_id IN %(team_ids)s AND cohort_id = %(cohort_id)s AND version < %(version)s
+GROUP BY team_id
+HAVING stale_people_count > 0
 """
diff --git a/posthog/models/cohort/util.py b/posthog/models/cohort/util.py
index fe589236fa62e..24350e5d3b8bb 100644
--- a/posthog/models/cohort/util.py
+++ b/posthog/models/cohort/util.py
@@ -34,13 +34,10 @@
     STALE_COHORTPEOPLE,
 )
 from posthog.models.person.sql import (
-    GET_LATEST_PERSON_SQL,
-    GET_PERSON_IDS_BY_FILTER,
     INSERT_PERSON_STATIC_COHORT,
     PERSON_STATIC_COHORT_TABLE,
 )
 from posthog.models.property import Property, PropertyGroup
-from posthog.queries.insight import insight_sync_execute
 from posthog.queries.person_distinct_id_query import get_team_distinct_ids_query
 
 # temporary marker to denote when cohortpeople table started being populated
@@ -75,14 +72,14 @@ def format_person_query(cohort: Cohort, index: int, hogql_context: HogQLContext)
     return query, params
 
 
-def print_cohort_hogql_query(cohort: Cohort, hogql_context: HogQLContext) -> str:
+def print_cohort_hogql_query(cohort: Cohort, hogql_context: HogQLContext, *, team: Team) -> str:
     from posthog.hogql_queries.query_runner import get_query_runner
 
     if not cohort.query:
         raise ValueError("Cohort has no query")
 
     query = get_query_runner(
-        cast(dict, cohort.query), team=cast(Team, cohort.team), limit_context=LimitContext.COHORT_CALCULATION
+        cast(dict, cohort.query), team=team, limit_context=LimitContext.COHORT_CALCULATION
     ).to_query()
 
     for select_query in extract_select_queries(query):
@@ -109,7 +106,7 @@ def print_cohort_hogql_query(cohort: Cohort, hogql_context: HogQLContext) -> str
 
     hogql_context.enable_select_queries = True
     hogql_context.limit_top_select = False
-    create_default_modifiers_for_team(cohort.team, hogql_context.modifiers)
+    create_default_modifiers_for_team(team, hogql_context.modifiers)
     return print_ast(query, context=hogql_context, dialect="clickhouse")
 
 
@@ -173,7 +170,7 @@ def get_entity_query(
     if event_id:
         return f"event = %({f'event_{group_idx}'})s", {f"event_{group_idx}": event_id}
     elif action_id:
-        action = Action.objects.get(pk=action_id, team_id=team_id)
+        action = Action.objects.get(pk=action_id)
         action_filter_query, action_params = format_action_filter(
             team_id=team_id,
             action=action,
@@ -262,10 +259,7 @@ def format_filter_query(
 
 
 def format_cohort_subquery(
-    cohort: Cohort,
-    index: int,
-    hogql_context: HogQLContext,
-    custom_match_field="person_id",
+    cohort: Cohort, index: int, hogql_context: HogQLContext, custom_match_field="person_id"
 ) -> tuple[str, dict[str, Any]]:
     is_precalculated = is_precalculated_query(cohort)
     if is_precalculated:
@@ -277,46 +271,13 @@ def format_cohort_subquery(
     return person_query, params
 
 
-def get_person_ids_by_cohort_id(
-    team: Team,
-    cohort_id: int,
-    limit: Optional[int] = None,
-    offset: Optional[int] = None,
-):
-    from posthog.models.property.util import parse_prop_grouped_clauses
-
-    filter = Filter(data={"properties": [{"key": "id", "value": cohort_id, "type": "cohort"}]})
-    filter_query, filter_params = parse_prop_grouped_clauses(
-        team_id=team.pk,
-        property_group=filter.property_groups,
-        table_name="pdi",
-        hogql_context=filter.hogql_context,
-    )
-
-    results = insight_sync_execute(
-        GET_PERSON_IDS_BY_FILTER.format(
-            person_query=GET_LATEST_PERSON_SQL,
-            distinct_query=filter_query,
-            query="",
-            GET_TEAM_PERSON_DISTINCT_IDS=get_team_distinct_ids_query(team.pk),
-            offset="OFFSET %(offset)s" if offset else "",
-            limit="ORDER BY _timestamp ASC LIMIT %(limit)s" if limit else "",
-        ),
-        {**filter_params, "team_id": team.pk, "offset": offset, "limit": limit},
-        query_type="get_person_ids_by_cohort_id",
-        team_id=team.pk,
-    )
-
-    return [str(row[0]) for row in results]
-
-
-def insert_static_cohort(person_uuids: list[Optional[uuid.UUID]], cohort_id: int, team: Team):
+def insert_static_cohort(person_uuids: list[Optional[uuid.UUID]], cohort_id: int, *, team_id: int):
     persons = [
         {
             "id": str(uuid.uuid4()),
             "person_id": str(person_uuid),
             "cohort_id": cohort_id,
-            "team_id": team.pk,
+            "team_id": team_id,
             "_timestamp": datetime.now(),
         }
         for person_uuid in person_uuids
@@ -324,12 +285,12 @@ def insert_static_cohort(person_uuids: list[Optional[uuid.UUID]], cohort_id: int
     sync_execute(INSERT_PERSON_STATIC_COHORT, persons)
 
 
-def get_static_cohort_size(cohort: Cohort) -> Optional[int]:
+def get_static_cohort_size(*, cohort_id: int, team_id: int) -> Optional[int]:
     count_result = sync_execute(
         GET_STATIC_COHORT_SIZE_SQL,
         {
-            "cohort_id": cohort.pk,
-            "team_id": cohort.team_id,
+            "cohort_id": cohort_id,
+            "team_id": team_id,
         },
     )
 
@@ -342,22 +303,39 @@ def get_static_cohort_size(cohort: Cohort) -> Optional[int]:
 def recalculate_cohortpeople(
     cohort: Cohort, pending_version: int, *, initiating_user_id: Optional[int]
 ) -> Optional[int]:
-    hogql_context = HogQLContext(within_non_hogql_query=True, team_id=cohort.team_id)
+    """
+    Recalculate cohort people for all environments of the project.
+    NOTE: Currently this only returns the count for the team where the cohort was created. Instead it should return for all teams.
+    """
+    relevant_teams = Team.objects.order_by("id").filter(project_id=cohort.team.project_id)
+    count_by_team_id: dict[int, int] = {}
+    for team in relevant_teams:
+        count_for_team = _recalculate_cohortpeople_for_team(
+            cohort, pending_version, team, initiating_user_id=initiating_user_id
+        )
+        count_by_team_id[team.id] = count_for_team or 0
+    return count_by_team_id[cohort.team_id]
+
+
+def _recalculate_cohortpeople_for_team(
+    cohort: Cohort, pending_version: int, team: Team, *, initiating_user_id: Optional[int]
+) -> Optional[int]:
+    hogql_context = HogQLContext(within_non_hogql_query=True, team_id=team.id)
     cohort_query, cohort_params = format_person_query(cohort, 0, hogql_context)
 
-    before_count = get_cohort_size(cohort)
+    before_count = get_cohort_size(cohort, team_id=team.id)
 
     if before_count:
         logger.warn(
             "Recalculating cohortpeople starting",
-            team_id=cohort.team_id,
+            team_id=team.id,
             cohort_id=cohort.pk,
             size_before=before_count,
         )
 
     recalcluate_cohortpeople_sql = RECALCULATE_COHORT_BY_ID.format(cohort_filter=cohort_query)
 
-    tag_queries(kind="cohort_calculation", team_id=cohort.team_id, query_type="CohortsQuery")
+    tag_queries(kind="cohort_calculation", team_id=team.id, query_type="CohortsQuery")
     if initiating_user_id:
         tag_queries(user_id=initiating_user_id)
 
@@ -367,7 +345,7 @@ def recalculate_cohortpeople(
             **cohort_params,
             **hogql_context.values,
             "cohort_id": cohort.pk,
-            "team_id": cohort.team_id,
+            "team_id": team.id,
             "new_version": pending_version,
         },
         settings={
@@ -379,12 +357,12 @@ def recalculate_cohortpeople(
         workload=Workload.OFFLINE,
     )
 
-    count = get_cohort_size(cohort, override_version=pending_version)
+    count = get_cohort_size(cohort, override_version=pending_version, team_id=team.id)
 
     if count is not None and before_count is not None:
         logger.warn(
             "Recalculating cohortpeople done",
-            team_id=cohort.team_id,
+            team_id=team.id,
             cohort_id=cohort.pk,
             size_before=before_count,
             size=count,
@@ -395,33 +373,40 @@ def recalculate_cohortpeople(
 
 def clear_stale_cohortpeople(cohort: Cohort, before_version: int) -> None:
     if cohort.version and cohort.version > 0:
+        relevant_team_ids = list(Team.objects.filter(project_id=cohort.team.project_id).values_list("pk", flat=True))
         stale_count_result = sync_execute(
             STALE_COHORTPEOPLE,
             {
                 "cohort_id": cohort.pk,
-                "team_id": cohort.team_id,
+                "team_ids": relevant_team_ids,
                 "version": before_version,
             },
         )
 
-        if stale_count_result and len(stale_count_result) and len(stale_count_result[0]):
-            stale_count = stale_count_result[0][0]
-            if stale_count > 0:
-                # Don't do anything if it already exists
-                AsyncDeletion.objects.get_or_create(
-                    deletion_type=DeletionType.Cohort_stale,
-                    team_id=cohort.team.pk,
-                    key=f"{cohort.pk}_{before_version}",
-                )
+        team_ids_with_stale_cohortpeople = [row[0] for row in stale_count_result]
+        if team_ids_with_stale_cohortpeople:
+            AsyncDeletion.objects.bulk_create(
+                [
+                    AsyncDeletion(
+                        deletion_type=DeletionType.Cohort_stale,
+                        team_id=team_id,
+                        # Only appending `team_id` if it's not the same as the cohort's `team_id``, so that
+                        # the migration to environments does not accidentally cause duplicate `AsyncDeletion`s
+                        key=f"{cohort.pk}_{before_version}{('_'+team_id) if team_id != cohort.team_id else ''}",
+                    )
+                    for team_id in team_ids_with_stale_cohortpeople
+                ],
+                ignore_conflicts=True,
+            )
 
 
-def get_cohort_size(cohort: Cohort, override_version: Optional[int] = None) -> Optional[int]:
+def get_cohort_size(cohort: Cohort, override_version: Optional[int] = None, *, team_id: int) -> Optional[int]:
     count_result = sync_execute(
         GET_COHORT_SIZE_SQL,
         {
             "cohort_id": cohort.pk,
             "version": override_version if override_version is not None else cohort.version,
-            "team_id": cohort.team_id,
+            "team_id": team_id,
         },
         workload=Workload.OFFLINE,
     )
@@ -545,7 +530,7 @@ def get_dependent_cohorts(
                     continue
             else:
                 current_cohort = Cohort.objects.db_manager(using_database).get(
-                    pk=cohort_id, team_id=cohort.team_id, deleted=False
+                    pk=cohort_id, team__project_id=cohort.team.project_id, deleted=False
                 )
                 seen_cohorts_cache[cohort_id] = current_cohort
             if current_cohort.id not in seen_cohort_ids:
diff --git a/posthog/models/dashboard_templates.py b/posthog/models/dashboard_templates.py
index 4826be8c9acfa..e8fb368a492ca 100644
--- a/posthog/models/dashboard_templates.py
+++ b/posthog/models/dashboard_templates.py
@@ -69,12 +69,29 @@ def original_template() -> "DashboardTemplate":
                     "name": "Daily active users (DAUs)",
                     "type": "INSIGHT",
                     "color": "blue",
-                    "filters": {
-                        "events": [{"id": "$pageview", "math": "dau", "type": "events"}],
-                        "display": "ActionsLineGraph",
-                        "insight": "TRENDS",
-                        "interval": "day",
-                        "date_from": "-30d",
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "TrendsQuery",
+                            "series": [
+                                {"kind": "EventsNode", "math": "dau", "name": "$pageview", "event": "$pageview"}
+                            ],
+                            "interval": "day",
+                            "dateRange": {"date_from": "-30d", "explicitDate": False},
+                            "properties": [],
+                            "trendsFilter": {
+                                "display": "ActionsLineGraph",
+                                "showLegend": False,
+                                "yAxisScaleType": "linear",
+                                "showValuesOnSeries": False,
+                                "smoothingIntervals": 1,
+                                "showPercentStackView": False,
+                                "aggregationAxisFormat": "numeric",
+                                "showAlertThresholdLines": False,
+                            },
+                            "breakdownFilter": {"breakdown_type": "event"},
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 0, "y": 0, "minH": 5, "minW": 3},
@@ -86,18 +103,29 @@ def original_template() -> "DashboardTemplate":
                     "name": "Weekly active users (WAUs)",
                     "type": "INSIGHT",
                     "color": "green",
-                    "filters": {
-                        "events": [
-                            {
-                                "id": "$pageview",
-                                "math": "dau",
-                                "type": "events",
-                            }
-                        ],
-                        "display": "ActionsLineGraph",
-                        "insight": "TRENDS",
-                        "interval": "week",
-                        "date_from": "-90d",
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "TrendsQuery",
+                            "series": [
+                                {"kind": "EventsNode", "math": "dau", "name": "$pageview", "event": "$pageview"}
+                            ],
+                            "interval": "week",
+                            "dateRange": {"date_from": "-90d", "explicitDate": False},
+                            "properties": [],
+                            "trendsFilter": {
+                                "display": "ActionsLineGraph",
+                                "showLegend": False,
+                                "yAxisScaleType": "linear",
+                                "showValuesOnSeries": False,
+                                "smoothingIntervals": 1,
+                                "showPercentStackView": False,
+                                "aggregationAxisFormat": "numeric",
+                                "showAlertThresholdLines": False,
+                            },
+                            "breakdownFilter": {"breakdown_type": "event"},
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 6, "y": 0, "minH": 5, "minW": 3},
@@ -109,12 +137,21 @@ def original_template() -> "DashboardTemplate":
                     "name": "Retention",
                     "type": "INSIGHT",
                     "color": "blue",
-                    "filters": {
-                        "period": "Week",
-                        "insight": "RETENTION",
-                        "target_entity": {"id": "$pageview", "type": "events"},
-                        "retention_type": "retention_first_time",
-                        "returning_entity": {"id": "$pageview", "type": "events"},
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "RetentionQuery",
+                            "dateRange": {"date_from": "-7d", "explicitDate": False},
+                            "properties": [],
+                            "retentionFilter": {
+                                "period": "Week",
+                                "targetEntity": {"id": "$pageview", "type": "events"},
+                                "retentionType": "retention_first_time",
+                                "totalIntervals": 11,
+                                "returningEntity": {"id": "$pageview", "type": "events"},
+                            },
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 6, "y": 5, "minH": 5, "minW": 3},
@@ -126,13 +163,17 @@ def original_template() -> "DashboardTemplate":
                     "name": "Growth accounting",
                     "type": "INSIGHT",
                     "color": "purple",
-                    "filters": {
-                        "events": [{"id": "$pageview", "type": "events"}],
-                        "insight": "LIFECYCLE",
-                        "interval": "week",
-                        "shown_as": "Lifecycle",
-                        "date_from": "-30d",
-                        "entity_type": "events",
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "LifecycleQuery",
+                            "series": [{"kind": "EventsNode", "name": "$pageview", "event": "$pageview"}],
+                            "interval": "week",
+                            "dateRange": {"date_from": "-30d", "explicitDate": False},
+                            "properties": [],
+                            "lifecycleFilter": {"showLegend": False},
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 0, "y": 5, "minH": 5, "minW": 3},
@@ -144,14 +185,29 @@ def original_template() -> "DashboardTemplate":
                     "name": "Referring domain (last 14 days)",
                     "type": "INSIGHT",
                     "color": "black",
-                    "filters": {
-                        "events": [{"id": "$pageview", "math": "dau", "type": "events"}],
-                        "display": "ActionsBarValue",
-                        "insight": "TRENDS",
-                        "interval": "day",
-                        "breakdown": "$referring_domain",
-                        "date_from": "-14d",
-                        "breakdown_type": "event",
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "TrendsQuery",
+                            "series": [
+                                {"kind": "EventsNode", "math": "dau", "name": "$pageview", "event": "$pageview"}
+                            ],
+                            "interval": "day",
+                            "dateRange": {"date_from": "-14d", "explicitDate": False},
+                            "properties": [],
+                            "trendsFilter": {
+                                "display": "ActionsBarValue",
+                                "showLegend": False,
+                                "yAxisScaleType": "linear",
+                                "showValuesOnSeries": False,
+                                "smoothingIntervals": 1,
+                                "showPercentStackView": False,
+                                "aggregationAxisFormat": "numeric",
+                                "showAlertThresholdLines": False,
+                            },
+                            "breakdownFilter": {"breakdown": "$referring_domain", "breakdown_type": "event"},
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 0, "y": 10, "minH": 5, "minW": 3},
@@ -163,35 +219,46 @@ def original_template() -> "DashboardTemplate":
                     "name": "Pageview funnel, by browser",
                     "type": "INSIGHT",
                     "color": "green",
-                    "filters": {
-                        "events": [
-                            {
-                                "id": "$pageview",
-                                "type": "events",
-                                "order": 0,
-                                "custom_name": "First page view",
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "FunnelsQuery",
+                            "series": [
+                                {
+                                    "kind": "EventsNode",
+                                    "name": "$pageview",
+                                    "event": "$pageview",
+                                    "custom_name": "First page view",
+                                },
+                                {
+                                    "kind": "EventsNode",
+                                    "name": "$pageview",
+                                    "event": "$pageview",
+                                    "custom_name": "Second page view",
+                                },
+                                {
+                                    "kind": "EventsNode",
+                                    "name": "$pageview",
+                                    "event": "$pageview",
+                                    "custom_name": "Third page view",
+                                },
+                            ],
+                            "interval": "day",
+                            "dateRange": {"date_from": "-7d", "explicitDate": False},
+                            "properties": [],
+                            "funnelsFilter": {
+                                "layout": "horizontal",
+                                "exclusions": [],
+                                "funnelVizType": "steps",
+                                "funnelOrderType": "ordered",
+                                "funnelStepReference": "total",
+                                "funnelWindowInterval": 14,
+                                "breakdownAttributionType": "first_touch",
+                                "funnelWindowIntervalUnit": "day",
                             },
-                            {
-                                "id": "$pageview",
-                                "type": "events",
-                                "order": 1,
-                                "custom_name": "Second page view",
-                            },
-                            {
-                                "id": "$pageview",
-                                "type": "events",
-                                "order": 2,
-                                "custom_name": "Third page view",
-                            },
-                        ],
-                        "layout": "horizontal",
-                        "display": "FunnelViz",
-                        "insight": "FUNNELS",
-                        "interval": "day",
-                        "exclusions": [],
-                        "breakdown_type": "event",
-                        "breakdown": "$browser",
-                        "funnel_viz_type": "steps",
+                            "breakdownFilter": {"breakdown": "$browser", "breakdown_type": "event"},
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 6, "y": 10, "minH": 5, "minW": 3},
@@ -214,12 +281,29 @@ def feature_flag_template(feature_flag_key: str) -> "DashboardTemplate":
                     "name": "Daily active users (DAUs)",
                     "type": "INSIGHT",
                     "color": "blue",
-                    "filters": {
-                        "events": [{"id": "$pageview", "math": "dau", "type": "events"}],
-                        "display": "ActionsLineGraph",
-                        "insight": "TRENDS",
-                        "interval": "day",
-                        "date_from": "-30d",
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "TrendsQuery",
+                            "series": [
+                                {"kind": "EventsNode", "math": "dau", "name": "$pageview", "event": "$pageview"}
+                            ],
+                            "interval": "day",
+                            "dateRange": {"date_from": "-30d", "explicitDate": False},
+                            "properties": [],
+                            "trendsFilter": {
+                                "display": "ActionsLineGraph",
+                                "showLegend": False,
+                                "yAxisScaleType": "linear",
+                                "showValuesOnSeries": False,
+                                "smoothingIntervals": 1,
+                                "showPercentStackView": False,
+                                "aggregationAxisFormat": "numeric",
+                                "showAlertThresholdLines": False,
+                            },
+                            "breakdownFilter": {"breakdown_type": "event"},
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 0, "y": 0, "minH": 5, "minW": 3},
@@ -231,18 +315,29 @@ def feature_flag_template(feature_flag_key: str) -> "DashboardTemplate":
                     "name": "Weekly active users (WAUs)",
                     "type": "INSIGHT",
                     "color": "green",
-                    "filters": {
-                        "events": [
-                            {
-                                "id": "$pageview",
-                                "math": "dau",
-                                "type": "events",
-                            }
-                        ],
-                        "display": "ActionsLineGraph",
-                        "insight": "TRENDS",
-                        "interval": "week",
-                        "date_from": "-90d",
+                    "query": {
+                        "kind": "InsightVizNode",
+                        "source": {
+                            "kind": "TrendsQuery",
+                            "series": [
+                                {"kind": "EventsNode", "math": "dau", "name": "$pageview", "event": "$pageview"}
+                            ],
+                            "interval": "week",
+                            "dateRange": {"date_from": "-90d", "explicitDate": False},
+                            "properties": [],
+                            "trendsFilter": {
+                                "display": "ActionsLineGraph",
+                                "showLegend": False,
+                                "yAxisScaleType": "linear",
+                                "showValuesOnSeries": False,
+                                "smoothingIntervals": 1,
+                                "showPercentStackView": False,
+                                "aggregationAxisFormat": "numeric",
+                                "showAlertThresholdLines": False,
+                            },
+                            "breakdownFilter": {"breakdown_type": "event"},
+                            "filterTestAccounts": False,
+                        },
                     },
                     "layouts": {
                         "sm": {"h": 5, "w": 6, "x": 6, "y": 0, "minH": 5, "minW": 3},
diff --git a/posthog/models/error_tracking/error_tracking.py b/posthog/models/error_tracking/error_tracking.py
index b003e29b3b8a5..47ae96334b5f7 100644
--- a/posthog/models/error_tracking/error_tracking.py
+++ b/posthog/models/error_tracking/error_tracking.py
@@ -1,10 +1,14 @@
-from django.db import models
+from django.db import models, transaction
 from django.contrib.postgres.fields import ArrayField
+
 from posthog.models.utils import UUIDModel
 from posthog.models.team import Team
 from posthog.models.user import User
-from django.db import transaction
-from django.db.models import Q, QuerySet
+from posthog.models.error_tracking.sql import INSERT_ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES
+
+from posthog.kafka_client.client import ClickhouseProducer
+from posthog.kafka_client.topics import KAFKA_ERROR_TRACKING_ISSUE_FINGERPRINT
+from uuid import UUID
 
 
 class ErrorTrackingIssue(UUIDModel):
@@ -20,6 +24,30 @@ class Status(models.TextChoices):
     name = models.TextField(null=True, blank=True)
     description = models.TextField(null=True, blank=True)
 
+    def merge(self, issue_ids: list[str]) -> None:
+        fingerprints = resolve_fingerprints_for_issues(team_id=self.team.pk, issue_ids=issue_ids)
+
+        with transaction.atomic():
+            overrides = update_error_tracking_issue_fingerprints(
+                team_id=self.team.pk, issue_id=self.id, fingerprints=fingerprints
+            )
+            ErrorTrackingIssue.objects.filter(team=self.team, id__in=issue_ids).delete()
+            update_error_tracking_issue_fingerprint_overrides(team_id=self.team.pk, overrides=overrides)
+
+    def split(self, fingerprints: list[str]) -> None:
+        overrides: list[ErrorTrackingIssueFingerprintV2] = []
+
+        for fingerprint in fingerprints:
+            with transaction.atomic():
+                new_issue = ErrorTrackingIssue.objects.create(team=self.team)
+                overrides.extend(
+                    update_error_tracking_issue_fingerprints(
+                        team_id=self.team.pk, issue_id=new_issue.id, fingerprints=[fingerprint]
+                    )
+                )
+
+        update_error_tracking_issue_fingerprint_overrides(team_id=self.team.pk, overrides=overrides)
+
 
 class ErrorTrackingIssueAssignment(UUIDModel):
     issue = models.ForeignKey(ErrorTrackingIssue, on_delete=models.CASCADE)
@@ -114,36 +142,6 @@ class Status(models.TextChoices):
         blank=True,
     )
 
-    @classmethod
-    def filter_fingerprints(cls, queryset, fingerprints: list[list]) -> QuerySet:
-        query = Q(fingerprint__in=fingerprints)
-
-        for fp in fingerprints:
-            query |= Q(merged_fingerprints__contains=fp)
-
-        return queryset.filter(query)
-
-    @transaction.atomic
-    def merge(self, fingerprints: list[list[str]]) -> None:
-        if not fingerprints:
-            return
-
-        # sets don't like lists so we're converting fingerprints to tuples
-        def convert_fingerprints_to_tuples(fps: list[list[str]]):
-            return [tuple(f) for f in fps]
-
-        merged_fingerprints = set(convert_fingerprints_to_tuples(self.merged_fingerprints))
-        merged_fingerprints.update(convert_fingerprints_to_tuples(fingerprints))
-
-        merging_groups = ErrorTrackingGroup.objects.filter(team=self.team, fingerprint__in=fingerprints)
-        for group in merging_groups:
-            merged_fingerprints |= set(convert_fingerprints_to_tuples(group.merged_fingerprints))
-
-        merging_groups.delete()
-        # converting back to list of lists before saving
-        self.merged_fingerprints = [list(f) for f in merged_fingerprints]
-        self.save()
-
 
 # DEPRECATED: Use ErrorTrackingIssueFingerprintV2 instead
 class ErrorTrackingIssueFingerprint(models.Model):
@@ -155,3 +153,59 @@ class ErrorTrackingIssueFingerprint(models.Model):
 
     class Meta:
         constraints = [models.UniqueConstraint(fields=["team", "fingerprint"], name="unique fingerprint for team")]
+
+
+def resolve_fingerprints_for_issues(team_id: int, issue_ids: list[str]) -> list[str]:
+    return list(
+        ErrorTrackingIssueFingerprintV2.objects.filter(team_id=team_id, issue_id__in=issue_ids).values_list(
+            "fingerprint", flat=True
+        )
+    )
+
+
+def update_error_tracking_issue_fingerprints(
+    team_id: int, issue_id: str, fingerprints: list[str]
+) -> list[ErrorTrackingIssueFingerprintV2]:
+    return list(
+        ErrorTrackingIssueFingerprintV2.objects.raw(
+            """
+                UPDATE posthog_errortrackingissuefingerprintv2
+                SET version = version + 1, issue_id = %s
+                WHERE team_id = %s AND fingerprint = ANY(%s)
+                RETURNING fingerprint, version, issue_id, id
+            """,
+            [issue_id, team_id, fingerprints],
+        )
+    )
+
+
+def update_error_tracking_issue_fingerprint_overrides(
+    team_id: int, overrides: list[ErrorTrackingIssueFingerprintV2]
+) -> None:
+    for override in overrides:
+        override_error_tracking_issue_fingerprint(
+            team_id=team_id, fingerprint=override.fingerprint, issue_id=override.issue_id, version=override.version
+        )
+
+
+def override_error_tracking_issue_fingerprint(
+    team_id: int,
+    fingerprint: str,
+    issue_id: UUID,
+    version=0,
+    is_deleted: bool = False,
+    sync: bool = False,
+) -> None:
+    p = ClickhouseProducer()
+    p.produce(
+        topic=KAFKA_ERROR_TRACKING_ISSUE_FINGERPRINT,
+        sql=INSERT_ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES,
+        data={
+            "team_id": team_id,
+            "fingerprint": fingerprint,
+            "issue_id": str(issue_id),
+            "version": version,
+            "is_deleted": int(is_deleted),
+        },
+        sync=sync,
+    )
diff --git a/posthog/models/error_tracking/sql.py b/posthog/models/error_tracking/sql.py
index 1700a6c7c4cd9..2bd96fb8956af 100644
--- a/posthog/models/error_tracking/sql.py
+++ b/posthog/models/error_tracking/sql.py
@@ -77,3 +77,7 @@
 TRUNCATE_ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES_TABLE_SQL = (
     f"TRUNCATE TABLE IF EXISTS {ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES_TABLE} ON CLUSTER '{CLICKHOUSE_CLUSTER}'"
 )
+
+INSERT_ERROR_TRACKING_ISSUE_FINGERPRINT_OVERRIDES = """
+INSERT INTO error_tracking_issue_fingerprint_overrides (fingerprint, issue_id, team_id, is_deleted, version, _timestamp, _offset, _partition) SELECT %(fingerprint)s, %(issue_id)s, %(team_id)s, %(is_deleted)s, %(version)s, now(), 0, 0 VALUES
+"""
diff --git a/posthog/models/error_tracking/test/test_error_tracking.py b/posthog/models/error_tracking/test/test_error_tracking.py
index 8ccb762c8eda8..91db5c014c090 100644
--- a/posthog/models/error_tracking/test/test_error_tracking.py
+++ b/posthog/models/error_tracking/test/test_error_tracking.py
@@ -1,60 +1,76 @@
-# class TestErrorTracking(BaseTest):
-#     def test_defaults(self):
-#         group = ErrorTrackingGroup.objects.create(status="active", team=self.team, fingerprint=["a_fingerprint"])
-
-#         assert group.fingerprint == ["a_fingerprint"]
-#         assert group.merged_fingerprints == []
-#         assert group.assignee is None
-
-#     def test_filtering(self):
-#         ErrorTrackingGroup.objects.bulk_create(
-#             [
-#                 ErrorTrackingGroup(team=self.team, fingerprint=["first_error"]),
-#                 ErrorTrackingGroup(
-#                     team=self.team, fingerprint=["second_error"], merged_fingerprints=[["previously_merged"]]
-#                 ),
-#                 ErrorTrackingGroup(team=self.team, fingerprint=["third_error"]),
-#             ]
-#         )
-
-#         matching_groups = ErrorTrackingGroup.objects.filter(fingerprint__in=[["first_error"], ["second_error"]])
-#         assert matching_groups.count() == 2
-
-#         matching_groups = ErrorTrackingGroup.objects.filter(merged_fingerprints__contains=["previously_merged"])
-#         assert matching_groups.count() == 1
-
-#         matching_groups = ErrorTrackingGroup.filter_fingerprints(
-#             queryset=ErrorTrackingGroup.objects, fingerprints=[["first_error"], ["previously_merged"]]
-#         )
-#         assert matching_groups.count() == 2
-
-#     def test_merge(self):
-#         primary_group = ErrorTrackingGroup.objects.create(
-#             status="active",
-#             team=self.team,
-#             fingerprint=["a_fingerprint"],
-#             merged_fingerprints=[["already_merged_fingerprint"]],
-#         )
-#         merge_group_1 = ErrorTrackingGroup.objects.create(
-#             status="active", team=self.team, fingerprint=["new_fingerprint"]
-#         )
-#         merge_group_2 = ErrorTrackingGroup.objects.create(
-#             status="active",
-#             team=self.team,
-#             fingerprint=["another_fingerprint"],
-#             merged_fingerprints=[["merged_fingerprint"]],
-#         )
-
-#         merging_fingerprints = [merge_group_1.fingerprint, merge_group_2.fingerprint, ["no_group_fingerprint"]]
-#         primary_group.merge(merging_fingerprints)
-
-#         assert sorted(primary_group.merged_fingerprints) == [
-#             ["already_merged_fingerprint"],
-#             ["another_fingerprint"],
-#             ["merged_fingerprint"],
-#             ["new_fingerprint"],
-#             ["no_group_fingerprint"],
-#         ]
-
-#         # deletes the old groups
-#         assert ErrorTrackingGroup.objects.count() == 1
+from posthog.test.base import BaseTest
+from posthog.models.error_tracking import ErrorTrackingIssue, ErrorTrackingIssueFingerprintV2
+
+
+class TestErrorTracking(BaseTest):
+    def create_issue(self, fingerprints) -> ErrorTrackingIssue:
+        issue = ErrorTrackingIssue.objects.create(team=self.team)
+        for fingerprint in fingerprints:
+            ErrorTrackingIssueFingerprintV2.objects.create(team=self.team, issue=issue, fingerprint=fingerprint)
+        return issue
+
+    def test_defaults(self):
+        issue = ErrorTrackingIssue.objects.create(team=self.team)
+
+        assert issue.status == "active"
+        assert issue.name is None
+
+    def test_basic_merge(self):
+        issue_one = self.create_issue(["fingerprint_one"])
+        issue_two = self.create_issue(["fingerprint_two"])
+
+        issue_two.merge(issue_ids=[issue_one.id])
+
+        # remaps the first fingerprint to the second issue
+        assert ErrorTrackingIssueFingerprintV2.objects.filter(issue_id=issue_two.id).count() == 2
+        # bumps the version
+        override = ErrorTrackingIssueFingerprintV2.objects.filter(fingerprint="fingerprint_one").first()
+        assert override
+        assert override.version == 1
+
+        # deletes issue one
+        assert ErrorTrackingIssue.objects.count() == 1
+
+    def test_merge_multiple_times(self):
+        issue_one = self.create_issue(["fingerprint_one"])
+        issue_two = self.create_issue(["fingerprint_two"])
+        issue_three = self.create_issue(["fingerprint_three"])
+
+        issue_two.merge(issue_ids=[issue_one.id])
+        issue_three.merge(issue_ids=[issue_two.id])
+
+        # only the third issue remains
+        assert ErrorTrackingIssue.objects.count() == 1
+        # all fingerprints point to the third issue
+        assert ErrorTrackingIssueFingerprintV2.objects.filter(issue_id=issue_three.id).count() == 3
+
+        # bumps versions of the merged issues correct number of times
+        override = ErrorTrackingIssueFingerprintV2.objects.filter(fingerprint="fingerprint_one").first()
+        assert override
+        assert override.version == 2
+        override = ErrorTrackingIssueFingerprintV2.objects.filter(fingerprint="fingerprint_two").first()
+        assert override
+        assert override.version == 1
+
+    def test_merging_multiple_issues_at_once(self):
+        issue_one = self.create_issue(["fingerprint_one"])
+        issue_two = self.create_issue(["fingerprint_two"])
+        issue_three = self.create_issue(["fingerprint_three"])
+
+        issue_three.merge(issue_ids=[issue_one.id, issue_two.id])
+
+        assert ErrorTrackingIssueFingerprintV2.objects.filter(issue_id=issue_three.id).count() == 3
+
+    def test_splitting_fingerprints(self):
+        issue = self.create_issue(["fingerprint_one", "fingerprint_two", "fingerprint_three"])
+
+        issue.split(fingerprints=["fingerprint_one", "fingerprint_two"])
+
+        # creates two new issues
+        assert ErrorTrackingIssue.objects.count() == 3
+
+        # bumps the version but no longer points to the old issue
+        override = ErrorTrackingIssueFingerprintV2.objects.filter(fingerprint="fingerprint_one").first()
+        assert override
+        assert override.issue_id != issue.id
+        assert override.version == 1
diff --git a/posthog/models/event/query_event_list.py b/posthog/models/event/query_event_list.py
index 0ea9b3242a298..7780b4f9980b8 100644
--- a/posthog/models/event/query_event_list.py
+++ b/posthog/models/event/query_event_list.py
@@ -115,7 +115,7 @@ def query_events_list(
 
     if action_id:
         try:
-            action = Action.objects.get(pk=action_id, team_id=team.pk)
+            action = Action.objects.get(pk=action_id, team__project_id=team.project_id)
             if not action.steps:
                 return []
         except Action.DoesNotExist:
diff --git a/posthog/models/event_definition.py b/posthog/models/event_definition.py
index 3f5c8d8a6f45b..9d1d574631858 100644
--- a/posthog/models/event_definition.py
+++ b/posthog/models/event_definition.py
@@ -3,7 +3,7 @@
 from django.utils import timezone
 
 from posthog.models.team import Team
-from posthog.models.utils import UUIDModel
+from posthog.models.utils import UUIDModel, UniqueConstraintByExpression
 
 
 class EventDefinition(UUIDModel):
@@ -13,6 +13,7 @@ class EventDefinition(UUIDModel):
         related_name="event_definitions",
         related_query_name="team",
     )
+    project = models.ForeignKey("Project", on_delete=models.CASCADE, null=True)
     name = models.CharField(max_length=400)
     created_at = models.DateTimeField(default=timezone.now, null=True)
     last_seen_at = models.DateTimeField(default=None, null=True)
@@ -26,13 +27,22 @@ class EventDefinition(UUIDModel):
     volume_30_day = models.IntegerField(default=None, null=True)
 
     class Meta:
-        unique_together = ("team", "name")
         indexes = [
+            # Index on project_id foreign key
+            models.Index(fields=["project"], name="posthog_eve_proj_id_f93fcbb0"),
             GinIndex(
                 name="index_event_definition_name",
                 fields=["name"],
                 opclasses=["gin_trgm_ops"],
-            )  # To speed up DB-based fuzzy searching
+            ),  # To speed up DB-based fuzzy searching
+        ]
+        unique_together = ("team", "name")
+        constraints = [
+            UniqueConstraintByExpression(
+                concurrently=True,
+                name="event_definition_proj_uniq",
+                expression="(coalesce(project_id, team_id), name)",
+            )
         ]
 
     def __str__(self) -> str:
diff --git a/posthog/models/event_property.py b/posthog/models/event_property.py
index a5087c5b3f667..4dc05a98e5701 100644
--- a/posthog/models/event_property.py
+++ b/posthog/models/event_property.py
@@ -1,11 +1,14 @@
 from django.db import models
 
 from posthog.models.team import Team
-from posthog.models.utils import sane_repr
+from posthog.models.utils import UniqueConstraintByExpression, sane_repr
+from django.db.models.expressions import F
+from django.db.models.functions import Coalesce
 
 
 class EventProperty(models.Model):
     team = models.ForeignKey(Team, on_delete=models.CASCADE)
+    project = models.ForeignKey("Project", on_delete=models.CASCADE, null=True)
     event = models.CharField(max_length=400, null=False)
     property = models.CharField(max_length=400, null=False)
 
@@ -14,11 +17,20 @@ class Meta:
             models.UniqueConstraint(
                 fields=["team", "event", "property"],
                 name="posthog_event_property_unique_team_event_property",
-            )
+            ),
+            UniqueConstraintByExpression(
+                concurrently=True,
+                name="posthog_event_property_unique_proj_event_property",
+                expression="(coalesce(project_id, team_id), event, property)",
+            ),
         ]
         indexes = [
+            # Index on project_id foreign key
+            models.Index(fields=["project"], name="posthog_eve_proj_id_dd2337d2"),
             models.Index(fields=["team", "event"]),
+            models.Index(Coalesce(F("project_id"), F("team_id")), F("event"), name="posthog_eve_proj_id_22de03_idx"),
             models.Index(fields=["team", "property"]),
+            models.Index(Coalesce(F("project_id"), F("team_id")), F("property"), name="posthog_eve_proj_id_26dbfb_idx"),
         ]
 
     __repr__ = sane_repr("event", "property", "team_id")
diff --git a/posthog/models/feature_flag/feature_flag.py b/posthog/models/feature_flag/feature_flag.py
index c21af6a397117..beca926b7fbac 100644
--- a/posthog/models/feature_flag/feature_flag.py
+++ b/posthog/models/feature_flag/feature_flag.py
@@ -187,7 +187,7 @@ def transform_cohort_filters_for_easy_evaluation(
                                     return self.conditions
                             else:
                                 cohort = Cohort.objects.db_manager(using_database).get(
-                                    pk=cohort_id, team_id=self.team_id, deleted=False
+                                    pk=cohort_id, team__project_id=self.team.project_id, deleted=False
                                 )
                                 seen_cohorts_cache[cohort_id] = cohort
                         except Cohort.DoesNotExist:
@@ -291,7 +291,7 @@ def get_cohort_ids(
                                 continue
                         else:
                             cohort = Cohort.objects.db_manager(using_database).get(
-                                pk=cohort_id, team_id=self.team_id, deleted=False
+                                pk=cohort_id, team__project_id=self.team.project_id, deleted=False
                             )
                             seen_cohorts_cache[cohort_id] = cohort
 
diff --git a/posthog/models/feature_flag/flag_analytics.py b/posthog/models/feature_flag/flag_analytics.py
index f62ed1934eca8..6579aa92d1041 100644
--- a/posthog/models/feature_flag/flag_analytics.py
+++ b/posthog/models/feature_flag/flag_analytics.py
@@ -139,9 +139,10 @@ def find_flags_with_enriched_analytics(begin: datetime, end: datetime):
     for row in result:
         team_id = row[0]
         flag_key = row[1]
+        team = Team.objects.only("project_id").get(id=team_id)
 
         try:
-            flag = FeatureFlag.objects.get(team_id=team_id, key=flag_key)
+            flag = FeatureFlag.objects.get(team__project_id=team.project_id, key=flag_key)
             if not flag.has_enriched_analytics:
                 flag.has_enriched_analytics = True
                 flag.save()
diff --git a/posthog/models/feature_flag/flag_matching.py b/posthog/models/feature_flag/flag_matching.py
index 573d766e65498..05182a7f1fede 100644
--- a/posthog/models/feature_flag/flag_matching.py
+++ b/posthog/models/feature_flag/flag_matching.py
@@ -829,6 +829,7 @@ def get_all_feature_flags(
     )
     all_feature_flags = get_feature_flags_for_team_in_cache(team_id)
     cache_hit = True
+
     if all_feature_flags is None:
         cache_hit = False
         all_feature_flags = set_feature_flags_for_team_in_cache(team_id)
diff --git a/posthog/models/feature_flag/flag_status.py b/posthog/models/feature_flag/flag_status.py
new file mode 100644
index 0000000000000..18caaa5814a5a
--- /dev/null
+++ b/posthog/models/feature_flag/flag_status.py
@@ -0,0 +1,172 @@
+import structlog
+
+from enum import StrEnum
+from .feature_flag import FeatureFlag
+
+logger = structlog.get_logger(__name__)
+
+FeatureFlagStatusReason = str
+
+
+class FeatureFlagStatus(StrEnum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    STALE = "stale"
+    DELETED = "deleted"
+    UNKNOWN = "unknown"
+
+
+# FeatureFlagStatusChecker is used to determine the status of a feature flag for a given user.
+# Eventually, this may be used to automatically archive old flags that are no longer in use.
+#
+# Status can be one of the following:
+# - ACTIVE: The feature flag is actively evaluated and the evaluations continue to vary.
+# - STALE: The feature flag has been fully rolled out to users. Its evaluations can not vary.
+# - INACTIVE: The feature flag is not being actively evaluated. STALE takes precedence over INACTIVE.
+#       NOTE: The "inactive" status is not currently used, but may be used in the future to automatically archive flags.
+# - DELETED: The feature flag has been soft deleted.
+# - UNKNOWN: The feature flag is not found in the database.
+class FeatureFlagStatusChecker:
+    def __init__(
+        self,
+        feature_flag_id: str,
+        # The amount of time considered "recent" for the purposes of determining staleness.
+        stale_window: str = "-30d",
+    ):
+        self.feature_flag_id = feature_flag_id
+        self.stale_window = stale_window
+
+    def get_status(self) -> tuple[FeatureFlagStatus, FeatureFlagStatusReason]:
+        try:
+            flag = FeatureFlag.objects.get(pk=self.feature_flag_id)
+        except FeatureFlag.DoesNotExist:
+            return FeatureFlagStatus.UNKNOWN, "Flag could not be found"
+
+        if flag.deleted:
+            return FeatureFlagStatus.DELETED, "Flag has been deleted"
+
+        # See if the flag is set to 100% on one variant (or 100% on rolled out and active if boolean flag).
+        is_flag_fully_rolled_out, fully_rolled_out_explanation = self.is_flag_fully_rolled_out(flag)
+        if is_flag_fully_rolled_out:
+            return FeatureFlagStatus.STALE, fully_rolled_out_explanation
+
+        return FeatureFlagStatus.ACTIVE, "Flag is not fully rolled out and may still be active"
+
+    def is_flag_fully_rolled_out(self, flag: FeatureFlag) -> tuple[bool, FeatureFlagStatusReason]:
+        # If flag is not active, it is not fully rolled out. This flag may still be stale,
+        # but only if isn't being evaluated, which will be determined later.
+        if not flag.active:
+            logger.debug(f"Flag {flag.id} is not active")
+            return False, ""
+
+        # If flag is using super groups and any super group is rolled out to 100%,
+        # it is fully rolled out.
+        if flag.filters.get("super_groups", None):
+            for super_group in flag.filters.get("super_groups"):
+                if self.is_group_fully_rolled_out(super_group):
+                    logger.debug(f"Flag {flag.id} has super group is rolled out to 100%")
+                    return True, "Super group is rolled out to 100%"
+
+        # If flag is using holdout groups and any holdout group is rolled out to 100%,
+        # it is fully rolled out.
+        if flag.filters.get("holdout_groups", None):
+            for holdout_group in flag.filters.get("holdout_groups"):
+                if self.is_group_fully_rolled_out(holdout_group):
+                    logger.debug(f"Flag {flag.id} has holdout group is rolled out to 100%")
+                    return True, "Holdout group is rolled out to 100%"
+
+        multivariate = flag.filters.get("multivariate", None)
+        if multivariate:
+            is_multivariate_flag_fully_rolled_out, fully_rolled_out_variant_name = (
+                self.is_multivariate_flag_fully_rolled_out(flag)
+            )
+        if multivariate and is_multivariate_flag_fully_rolled_out:
+            return True, f'This flag will always use the variant "{fully_rolled_out_variant_name}"'
+        elif not multivariate and self.is_boolean_flag_fully_rolled_out(flag):
+            return True, 'This boolean flag will always evaluate to "true"'
+
+        return False, ""
+
+    def is_multivariate_flag_fully_rolled_out(self, flag: FeatureFlag) -> tuple[bool, str]:
+        # If flag is multivariant and one variant is rolled out to 100%,
+        # and there is a release condition set to 100%, it is fully rolled out.
+        #
+        # Alternatively, if there is a release condition set to 100% and it has a
+        # variant override, the flag is fully rolled out.
+        fully_rolled_out_variant_key: str | None = None
+        some_release_condition_fully_rolled_out = False
+        fully_rolled_out_release_condition_variant_override: str | None = None
+
+        multivariate = flag.filters.get("multivariate", None)
+        variants = multivariate.get("variants", [])
+        for variant in variants:
+            if variant.get("rollout_percentage") == 100:
+                fully_rolled_out_variant_key = variant.get("key")
+                break
+
+        for release_condition in flag.filters.get("groups", []):
+            if self.is_group_fully_rolled_out(release_condition):
+                some_release_condition_fully_rolled_out = True
+                fully_rolled_out_release_condition_variant_override = (
+                    fully_rolled_out_release_condition_variant_override or release_condition.get("variant", None)
+                )
+
+        fully_rolled_out_variant = (
+            fully_rolled_out_release_condition_variant_override or fully_rolled_out_variant_key or ""
+        )
+        return some_release_condition_fully_rolled_out and (
+            fully_rolled_out_release_condition_variant_override is not None or fully_rolled_out_variant_key is not None
+        ), fully_rolled_out_variant
+
+    def is_group_fully_rolled_out(self, group: dict) -> bool:
+        rollout_percentage = group.get("rollout_percentage")
+        properties = group.get("properties", [])
+        return rollout_percentage == 100 and len(properties) == 0
+
+    def is_boolean_flag_fully_rolled_out(self, flag: FeatureFlag) -> bool:
+        # An active flag with no release conditions is still considered fully rolled out.
+        # This isn't a supported state, but in place to support legacy data.
+        if flag.filters is None or len(flag.filters) == 0:
+            logger.debug(f"Boolean flag {flag.id} has no release conditions, so it is rolled out to 100%")
+            return True
+
+        # If flag is boolean flag and rolled release conditions have rolled out to 100%, it is fully rolled out.
+        # The fully rolled out release condition must have no properties set.
+        release_conditions = flag.filters.get("groups", [])
+        for release_condition in release_conditions:
+            rollout_percentage = release_condition.get("rollout_percentage")
+            properties = release_condition.get("properties", [])
+            if rollout_percentage == 100 and len(properties) == 0:
+                logger.debug(f"Boolean flag {flag.id} has a release conditions rolled out to 100%")
+                return True
+
+        return False
+
+    def is_flag_unevaluated_recently(self, flag: FeatureFlag) -> bool:
+        recent_evaluations = self.get_recent_evaluations(flag)
+        return len(recent_evaluations) == 0
+
+    def get_recent_evaluations(self, flag: FeatureFlag) -> list[list[str]]:
+        from posthog.schema import EventsQuery, EventsQueryResponse
+        from posthog.hogql_queries.events_query_runner import EventsQueryRunner
+
+        eq = EventsQuery(
+            after=self.stale_window,
+            event="$feature_flag_called",
+            properties=[
+                {
+                    "key": "$feature_flag",
+                    "operator": "exact",
+                    "type": "event",
+                    "value": flag.key,
+                }
+            ],
+            select=[],
+            # We only care if there has been one or more recent call, so ask ClickHouse for one result
+            limit=1,
+        )
+
+        result: EventsQueryResponse = EventsQueryRunner(query=eq, team=flag.team).calculate()
+
+        logger.debug(f"Flag {flag.id} has {len(result.results)} recent ({self.stale_window}) calls")
+        return result.results
diff --git a/posthog/models/feature_flag/user_blast_radius.py b/posthog/models/feature_flag/user_blast_radius.py
index 712df09ed5002..bf08e8eed950a 100644
--- a/posthog/models/feature_flag/user_blast_radius.py
+++ b/posthog/models/feature_flag/user_blast_radius.py
@@ -77,7 +77,7 @@ def get_user_blast_radius(
 
         if len(cohort_filters) == 1:
             try:
-                target_cohort = Cohort.objects.get(id=cohort_filters[0].value, team=team)
+                target_cohort = Cohort.objects.get(id=cohort_filters[0].value, team__project_id=team.project_id)
             except Cohort.DoesNotExist:
                 pass
             finally:
diff --git a/posthog/models/feedback/survey.py b/posthog/models/feedback/survey.py
index 2fc8088d6902b..b178fea2418e9 100644
--- a/posthog/models/feedback/survey.py
+++ b/posthog/models/feedback/survey.py
@@ -292,7 +292,7 @@ def update_survey_iterations(sender, instance, *args, **kwargs):
 def update_surveys_opt_in(sender, instance, **kwargs):
     active_surveys_count = (
         Survey.objects.filter(
-            team_id=instance.team_id,
+            team__project_id=instance.team.project_id,
             start_date__isnull=False,
             end_date__isnull=True,
             archived=False,
diff --git a/posthog/models/filters/__init__.py b/posthog/models/filters/__init__.py
index fa75a96fc7308..89b22e15cb06f 100644
--- a/posthog/models/filters/__init__.py
+++ b/posthog/models/filters/__init__.py
@@ -3,7 +3,6 @@
 from .path_filter import PathFilter
 from .retention_filter import RetentionFilter
 from .stickiness_filter import StickinessFilter
-from .session_recordings_filter import SessionRecordingsFilter
 from .properties_timeline_filter import PropertiesTimelineFilter
 
 __all__ = [
@@ -11,13 +10,10 @@
     "PathFilter",
     "RetentionFilter",
     "StickinessFilter",
-    "SessionRecordingsFilter",
     "PropertiesTimelineFilter",
     "AnyFilter",
 ]
 
-AnyFilter: TypeAlias = (
-    Filter | PathFilter | RetentionFilter | StickinessFilter | SessionRecordingsFilter | PropertiesTimelineFilter
-)
+AnyFilter: TypeAlias = Filter | PathFilter | RetentionFilter | StickinessFilter | PropertiesTimelineFilter
 
 AnyInsightFilter: TypeAlias = Filter | PathFilter | RetentionFilter | StickinessFilter
diff --git a/posthog/models/filters/mixins/session_recordings.py b/posthog/models/filters/mixins/session_recordings.py
deleted file mode 100644
index e2df650f4a082..0000000000000
--- a/posthog/models/filters/mixins/session_recordings.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import json
-from typing import Optional, Literal, Union
-
-from posthog.hogql import ast
-from posthog.constants import PERSON_UUID_FILTER, SESSION_RECORDINGS_FILTER_IDS, PropertyOperatorType
-from posthog.models.filters.mixins.common import BaseParamMixin
-from posthog.models.filters.mixins.property import PropertyMixin
-from posthog.models.filters.mixins.utils import cached_property
-from posthog.models.property import PropertyGroup
-
-
-class PersonUUIDMixin(BaseParamMixin):
-    @cached_property
-    def person_uuid(self) -> Optional[str]:
-        return self._data.get(PERSON_UUID_FILTER, None)
-
-
-class SessionRecordingsMixin(PropertyMixin, BaseParamMixin):
-    @cached_property
-    def order(self) -> str:
-        return self._data.get("order", "start_time")
-
-    @cached_property
-    def console_log_filters(self) -> PropertyGroup:
-        property_group = self._parse_data(key="console_log_filters")
-        property_group.type = self.property_operand
-        return property_group
-
-    @cached_property
-    def property_operand(self) -> PropertyOperatorType:
-        return PropertyOperatorType.AND if self._operand == "AND" else PropertyOperatorType.OR
-
-    @cached_property
-    def ast_operand(self) -> type[Union[ast.And, ast.Or]]:
-        return ast.And if self._operand == "AND" else ast.Or
-
-    @cached_property
-    def _operand(self) -> Literal["AND"] | Literal["OR"]:
-        return self._data.get("operand", "AND")
-
-    @cached_property
-    def session_ids(self) -> Optional[list[str]]:
-        # Can be ['a', 'b'] or "['a', 'b']" or "a,b"
-        session_ids_str = self._data.get(SESSION_RECORDINGS_FILTER_IDS, None)
-
-        if session_ids_str is None:
-            return None
-
-        if isinstance(session_ids_str, list):
-            recordings_ids = session_ids_str
-        elif isinstance(session_ids_str, str):
-            if session_ids_str.startswith("["):
-                recordings_ids = json.loads(session_ids_str)
-            else:
-                recordings_ids = session_ids_str.split(",")
-
-        if all(isinstance(recording_id, str) for recording_id in recordings_ids):
-            # Sort for stable queries
-            return sorted(recordings_ids)
-
-        # If the property is at all present, we assume that the user wants to filter by it
-        return []
-
-    @cached_property
-    def having_predicates(self) -> PropertyGroup:
-        return self._parse_data(key="having_predicates")
diff --git a/posthog/models/filters/mixins/simplify.py b/posthog/models/filters/mixins/simplify.py
index b152e07113f11..01f3d2c4d4745 100644
--- a/posthog/models/filters/mixins/simplify.py
+++ b/posthog/models/filters/mixins/simplify.py
@@ -108,7 +108,7 @@ def _simplify_property(self, team: "Team", property: "Property", **kwargs) -> "P
             from posthog.models.cohort.util import simplified_cohort_filter_properties
 
             try:
-                cohort = Cohort.objects.get(pk=property.value, team_id=team.pk)
+                cohort = Cohort.objects.get(pk=property.value, team__project_id=team.project_id)
             except Cohort.DoesNotExist:
                 # :TODO: Handle non-existing resource in-query instead
                 return PropertyGroup(type=PropertyOperatorType.AND, values=[property])
diff --git a/posthog/models/filters/session_recordings_filter.py b/posthog/models/filters/session_recordings_filter.py
deleted file mode 100644
index f246e14ba0850..0000000000000
--- a/posthog/models/filters/session_recordings_filter.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from .filter import Filter
-from .mixins.session_recordings import PersonUUIDMixin, SessionRecordingsMixin
-
-
-class SessionRecordingsFilter(SessionRecordingsMixin, PersonUUIDMixin, Filter):
-    pass
diff --git a/posthog/models/filters/test/__snapshots__/test_filter.ambr b/posthog/models/filters/test/__snapshots__/test_filter.ambr
index 38d231d6b6360..773730e93858c 100644
--- a/posthog/models/filters/test/__snapshots__/test_filter.ambr
+++ b/posthog/models/filters/test/__snapshots__/test_filter.ambr
@@ -440,9 +440,10 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_cohort"."deleted"
          AND "posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   ORDER BY "posthog_cohort"."id" ASC
   LIMIT 1
   '''
@@ -517,9 +518,10 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_cohort"."deleted"
          AND "posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   ORDER BY "posthog_cohort"."id" ASC
   LIMIT 1
   '''
@@ -585,9 +587,10 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_cohort"."deleted"
          AND "posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   ORDER BY "posthog_cohort"."id" ASC
   LIMIT 1
   '''
@@ -613,9 +616,10 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_cohort"."deleted"
          AND "posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   ORDER BY "posthog_cohort"."id" ASC
   LIMIT 1
   '''
@@ -641,9 +645,10 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_cohort"."deleted"
          AND "posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   ORDER BY "posthog_cohort"."id" ASC
   LIMIT 1
   '''
@@ -669,9 +674,10 @@
          "posthog_cohort"."is_static",
          "posthog_cohort"."groups"
   FROM "posthog_cohort"
+  INNER JOIN "posthog_team" ON ("posthog_cohort"."team_id" = "posthog_team"."id")
   WHERE (NOT "posthog_cohort"."deleted"
          AND "posthog_cohort"."id" = 99999
-         AND "posthog_cohort"."team_id" = 99999)
+         AND "posthog_team"."project_id" = 99999)
   ORDER BY "posthog_cohort"."id" ASC
   LIMIT 1
   '''
diff --git a/posthog/models/hog_functions/hog_function.py b/posthog/models/hog_functions/hog_function.py
index 48e3db90a9dcd..3ddd0212f21d5 100644
--- a/posthog/models/hog_functions/hog_function.py
+++ b/posthog/models/hog_functions/hog_function.py
@@ -37,6 +37,7 @@ class HogFunctionType(models.TextChoices):
     DESTINATION = "destination"
     SITE_DESTINATION = "site_destination"
     SITE_APP = "site_app"
+    TRANSFORMATION = "transformation"
     EMAIL = "email"
     SMS = "sms"
     PUSH = "push"
@@ -45,7 +46,7 @@ class HogFunctionType(models.TextChoices):
     BROADCAST = "broadcast"
 
 
-TYPES_THAT_RELOAD_PLUGIN_SERVER = (HogFunctionType.DESTINATION, HogFunctionType.EMAIL)
+TYPES_THAT_RELOAD_PLUGIN_SERVER = (HogFunctionType.DESTINATION, HogFunctionType.EMAIL, HogFunctionType.TRANSFORMATION)
 TYPES_WITH_COMPILED_FILTERS = (HogFunctionType.DESTINATION,)
 TYPES_WITH_TRANSPILED_FILTERS = (HogFunctionType.SITE_DESTINATION, HogFunctionType.SITE_APP)
 TYPES_WITH_JAVASCRIPT_SOURCE = (HogFunctionType.SITE_DESTINATION, HogFunctionType.SITE_APP)
@@ -81,6 +82,7 @@ class Meta:
     encrypted_inputs: EncryptedJSONStringField = EncryptedJSONStringField(null=True, blank=True)
 
     filters = models.JSONField(null=True, blank=True)
+    mappings = models.JSONField(null=True, blank=True)
     masking = models.JSONField(null=True, blank=True)
     template_id = models.CharField(max_length=400, null=True, blank=True)
 
diff --git a/posthog/models/integration.py b/posthog/models/integration.py
index d8e49cc5d67aa..f42f70da332d9 100644
--- a/posthog/models/integration.py
+++ b/posthog/models/integration.py
@@ -163,7 +163,7 @@ def oauth_config_for_kind(cls, kind: str) -> OauthConfig:
                 authorize_url="https://app.hubspot.com/oauth/authorize",
                 token_url="https://api.hubapi.com/oauth/v1/token",
                 token_info_url="https://api.hubapi.com/oauth/v1/access-tokens/:access_token",
-                token_info_config_fields=["hub_id", "hub_domain", "user", "user_id"],
+                token_info_config_fields=["hub_id", "hub_domain", "user", "user_id", "scopes"],
                 client_id=settings.HUBSPOT_APP_CLIENT_ID,
                 client_secret=settings.HUBSPOT_APP_CLIENT_SECRET,
                 scope="tickets crm.objects.contacts.write sales-email-read crm.objects.companies.read crm.objects.deals.read crm.objects.contacts.read crm.objects.quotes.read crm.objects.companies.write",
@@ -187,7 +187,7 @@ def oauth_config_for_kind(cls, kind: str) -> OauthConfig:
                 token_url="https://oauth2.googleapis.com/token",
                 client_id=settings.SOCIAL_AUTH_GOOGLE_OAUTH2_KEY,
                 client_secret=settings.SOCIAL_AUTH_GOOGLE_OAUTH2_SECRET,
-                scope="https://www.googleapis.com/auth/adwords email",
+                scope="https://www.googleapis.com/auth/adwords https://www.googleapis.com/auth/userinfo.email",
                 id_path="sub",
                 name_path="email",
             )
diff --git a/posthog/models/messaging.py b/posthog/models/messaging.py
index 1f013ce09f75d..cd929d33b9986 100644
--- a/posthog/models/messaging.py
+++ b/posthog/models/messaging.py
@@ -19,6 +19,22 @@ def get_or_create(self, defaults=None, **kwargs):
 
         return super().get_or_create(defaults, **kwargs)
 
+    def filter(self, *args, **kwargs):
+        raw_email = kwargs.pop("raw_email", None)
+
+        if raw_email:
+            kwargs["email_hash"] = get_email_hash(raw_email)
+
+        return super().filter(*args, **kwargs)
+
+    def get(self, *args, **kwargs):
+        raw_email = kwargs.pop("raw_email", None)
+
+        if raw_email:
+            kwargs["email_hash"] = get_email_hash(raw_email)
+
+        return super().get(*args, **kwargs)
+
 
 class MessagingRecord(UUIDModel):
     objects = MessagingRecordManager()
diff --git a/posthog/models/product_intent/product_intent.py b/posthog/models/product_intent/product_intent.py
index 85ec938eb1129..c9d5f47f4b795 100644
--- a/posthog/models/product_intent/product_intent.py
+++ b/posthog/models/product_intent/product_intent.py
@@ -3,6 +3,9 @@
 from celery import shared_task
 from django.db import models
 
+from posthog.models.experiment import Experiment
+from posthog.models.feature_flag.feature_flag import FeatureFlag
+from posthog.models.feedback.survey import Survey
 from posthog.models.insight import Insight
 from posthog.models.team.team import Team
 from posthog.models.utils import UUIDModel
@@ -30,6 +33,10 @@
 about product usage because that limits our data exploration later. Definitely continue
 sending events for product usage that we may want to track for any reason, along with
 calculating activation here.
+
+Note: single-event activation metrics that can also happen at the same time the intent
+is created won't have tracking events sent for them. Unless you want to solve this,
+make activation metrics require multiple things to happen.
 """
 
 
@@ -58,7 +65,7 @@ def __str__(self):
 
     def has_activated_data_warehouse(self) -> bool:
         insights = Insight.objects.filter(
-            team=self.team,
+            team__project_id=self.team.project_id,
             created_at__gte=datetime(2024, 6, 1, tzinfo=UTC),
             query__kind="DataVisualizationNode",
         )
@@ -74,12 +81,50 @@ def has_activated_data_warehouse(self) -> bool:
 
         return False
 
-    def check_and_update_activation(self) -> None:
-        if self.product_type == "data_warehouse":
-            if self.has_activated_data_warehouse():
-                self.activated_at = datetime.now(tz=UTC)
-                self.save()
-                self.report_activation("data_warehouse")
+    def has_activated_experiments(self) -> bool:
+        # the team has any launched experiments
+        return Experiment.objects.filter(team=self.team, start_date__isnull=False).exists()
+
+    def has_activated_feature_flags(self) -> bool:
+        # Get feature flags that have at least one filter group, excluding ones used by experiments and surveys
+        experiment_flags = Experiment.objects.filter(team=self.team).values_list("feature_flag_id", flat=True)
+        survey_flags = Survey.objects.filter(team=self.team).values_list("targeting_flag_id", flat=True)
+
+        feature_flags = (
+            FeatureFlag.objects.filter(
+                team=self.team,
+                filters__groups__0__properties__isnull=False,
+            )
+            .exclude(id__in=experiment_flags)
+            .exclude(id__in=survey_flags)
+            .only("id", "filters")
+        )
+
+        # To activate we need at least 2 feature flags
+        if feature_flags.count() < 2:
+            return False
+
+        # To activate we need at least 2 filter groups across all flags
+        total_groups = 0
+        for flag in feature_flags:
+            total_groups += len(flag.filters.get("groups", []))
+
+        return total_groups >= 2
+
+    def check_and_update_activation(self, skip_reporting: bool = False) -> bool:
+        activation_checks = {
+            "data_warehouse": self.has_activated_data_warehouse,
+            "experiments": self.has_activated_experiments,
+            "feature_flags": self.has_activated_feature_flags,
+        }
+
+        if self.product_type in activation_checks and activation_checks[self.product_type]():
+            self.activated_at = datetime.now(tz=UTC)
+            self.save()
+            if not skip_reporting:
+                self.report_activation(self.product_type)
+            return True
+        return False
 
     def report_activation(self, product_key: str) -> None:
         from posthog.event_usage import report_team_action
diff --git a/posthog/models/property/util.py b/posthog/models/property/util.py
index 90651b6cd1e5f..ef63b2f69c670 100644
--- a/posthog/models/property/util.py
+++ b/posthog/models/property/util.py
@@ -14,10 +14,7 @@
 from rest_framework import exceptions
 
 from posthog.clickhouse.kafka_engine import trim_quotes_expr
-from posthog.clickhouse.materialized_columns import (
-    TableWithProperties,
-    get_enabled_materialized_columns,
-)
+from posthog.clickhouse.materialized_columns import TableWithProperties, get_materialized_column_for_property
 from posthog.constants import PropertyOperatorType
 from posthog.hogql import ast
 from posthog.hogql.hogql import HogQLContext
@@ -711,17 +708,18 @@ def get_property_string_expr(
         (optional) alias of the table being queried
     :return:
     """
-    materialized_columns = get_enabled_materialized_columns(table) if allow_denormalized_props else {}
-
     table_string = f"{table_alias}." if table_alias is not None and table_alias != "" else ""
 
     if (
         allow_denormalized_props
-        and (property_name, materialised_table_column) in materialized_columns
+        and (
+            materialized_column := get_materialized_column_for_property(table, materialised_table_column, property_name)
+        )
+        and not materialized_column.is_nullable
         and "group" not in materialised_table_column
     ):
         return (
-            f'{table_string}"{materialized_columns[(property_name, materialised_table_column)]}"',
+            f'{table_string}"{materialized_column.name}"',
             True,
         )
 
diff --git a/posthog/models/property_definition.py b/posthog/models/property_definition.py
index e2e77eba2148c..b4cc20797c89a 100644
--- a/posthog/models/property_definition.py
+++ b/posthog/models/property_definition.py
@@ -43,6 +43,7 @@ class Type(models.IntegerChoices):
         related_name="property_definitions",
         related_query_name="team",
     )
+    project = models.ForeignKey("Project", on_delete=models.CASCADE, null=True)
     name = models.CharField(max_length=400)
     is_numerical = models.BooleanField(
         default=False
@@ -69,6 +70,8 @@ class Type(models.IntegerChoices):
 
     class Meta:
         indexes = [
+            # Index on project_id foreign key
+            models.Index(fields=["project"], name="posthog_prop_proj_id_d3eb982d"),
             # This indexes the query in api/property_definition.py
             # :KLUDGE: django ORM typing is off here
             models.Index(
@@ -79,9 +82,23 @@ class Meta:
                 F("name").asc(),
                 name="index_property_def_query",
             ),
+            models.Index(
+                Coalesce(F("project_id"), F("team_id")),
+                F("type"),
+                Coalesce(F("group_type_index"), -1),
+                F("query_usage_30_day").desc(nulls_last=True),
+                F("name").asc(),
+                name="index_property_def_query_proj",
+            ),
             # creates an index pganalyze identified as missing
             # https://app.pganalyze.com/servers/i35ydkosi5cy5n7tly45vkjcqa/checks/index_advisor/missing_index/15282978
             models.Index(fields=["team_id", "type", "is_numerical"]),
+            models.Index(
+                Coalesce(F("project_id"), F("team_id")),
+                F("type"),
+                F("is_numerical"),
+                name="posthog_pro_project_3583d2_idx",
+            ),
             GinIndex(
                 name="index_property_definition_name",
                 fields=["name"],
@@ -101,6 +118,11 @@ class Meta:
                 name="posthog_propertydefinition_uniq",
                 expression="(team_id, name, type, coalesce(group_type_index, -1))",
             ),
+            UniqueConstraintByExpression(
+                concurrently=True,
+                name="posthog_propdef_proj_uniq",
+                expression="(coalesce(project_id, team_id), name, type, coalesce(group_type_index, -1))",
+            ),
         ]
 
     def __str__(self) -> str:
diff --git a/posthog/models/remote_config.py b/posthog/models/remote_config.py
new file mode 100644
index 0000000000000..17e6d45a40a8d
--- /dev/null
+++ b/posthog/models/remote_config.py
@@ -0,0 +1,450 @@
+import json
+import os
+from typing import Any, Optional
+from collections.abc import Callable
+from django.conf import settings
+from django.db import models
+from django.http import HttpRequest
+from django.utils import timezone
+from prometheus_client import Counter
+import requests
+from sentry_sdk import capture_exception
+import structlog
+
+from posthog.database_healthcheck import DATABASE_FOR_FLAG_MATCHING
+from posthog.models.feature_flag.feature_flag import FeatureFlag
+from posthog.models.feedback.survey import Survey
+from posthog.models.hog_functions.hog_function import HogFunction
+from posthog.models.plugin import PluginConfig
+from posthog.models.team.team import Team
+from posthog.models.utils import UUIDModel, execute_with_timeout
+
+from django.core.cache import cache
+from django.db.models.signals import post_save
+from django.dispatch.dispatcher import receiver
+
+
+CACHE_TIMEOUT = 60 * 60 * 24  # 1 day - it will be invalidated by the daily sync
+
+
+CELERY_TASK_REMOTE_CONFIG_SYNC = Counter(
+    "posthog_remote_config_sync",
+    "Number of times the remote config sync task has been run",
+    labelnames=["result"],
+)
+
+REMOTE_CONFIG_CACHE_COUNTER = Counter(
+    "posthog_remote_config_via_cache",
+    "Metric tracking whether a remote config was fetched from cache or not",
+    labelnames=["result"],
+)
+
+REMOTE_CONFIG_CDN_PURGE_COUNTER = Counter(
+    "posthog_remote_config_cdn_purge",
+    "Number of times the remote config CDN purge task has been run",
+    labelnames=["result"],
+)
+
+
+logger = structlog.get_logger(__name__)
+
+
+# Load the JS content from the frontend build
+_array_js_content: Optional[str] = None
+
+
+def get_array_js_content():
+    global _array_js_content
+
+    if _array_js_content is None:
+        with open(os.path.join(settings.BASE_DIR, "frontend/dist/array.js")) as f:
+            _array_js_content = f.read()
+
+    return _array_js_content
+
+
+def indent_js(js_content: str, indent: int = 4) -> str:
+    joined = "\n".join([f"{' ' * indent}{line}" for line in js_content.split("\n")])
+
+    return joined
+
+
+def cache_key_for_team_token(team_token: str, suffix: str) -> str:
+    return f"remote_config/{team_token}/{suffix}"
+
+
+def sanitize_config_for_public_cdn(config: dict, request: Optional[HttpRequest] = None) -> dict:
+    from posthog.api.utils import on_permitted_recording_domain
+
+    # Remove domains from session recording
+    if config.get("sessionRecording"):
+        if "domains" in config["sessionRecording"]:
+            domains = config["sessionRecording"].pop("domains")
+
+            # Empty list of domains means always permitted
+            if request and domains:
+                if not on_permitted_recording_domain(domains, request=request):
+                    config["sessionRecording"] = False
+
+    # Remove site apps JS
+    config.pop("siteAppsJS", None)
+    return config
+
+
+class RemoteConfig(UUIDModel):
+    """
+    RemoteConfig is a helper model. There is one per team and stores a highly cacheable JSON object
+    as well as JS code for the frontend. It's main function is to react to changes that would affect it,
+    update the JSON/JS configs and then sync to the optimized CDN endpoints (such as S3) as well as redis for our legacy
+    /decide fallback
+    """
+
+    team = models.OneToOneField("Team", on_delete=models.CASCADE)
+    config = models.JSONField()
+    updated_at = models.DateTimeField(auto_now=True)
+    synced_at = models.DateTimeField(null=True)
+
+    def build_config(self):
+        from posthog.models.feature_flag import FeatureFlag
+        from posthog.models.team import Team
+        from posthog.plugins.site import get_decide_site_apps
+        from posthog.api.survey import get_surveys_response
+
+        # NOTE: It is important this is changed carefully. This is what the SDK will load in place of "decide" so the format
+        # should be kept consistent. The JS code should be minified and the JSON should be as small as possible.
+        # It is very close to the original decide payload but with fewer options as it is new and allowed us to drop some old values
+
+        team: Team = self.team
+
+        # NOTE: Let's try and keep this tidy! Follow the styling of the values already here...
+        config = {
+            "token": team.api_token,
+            "supportedCompression": ["gzip", "gzip-js"],
+            "hasFeatureFlags": FeatureFlag.objects.filter(team=team, active=True, deleted=False).count() > 0,
+            "captureDeadClicks": bool(team.capture_dead_clicks),
+            "capturePerformance": (
+                {
+                    "network_timing": bool(team.capture_performance_opt_in),
+                    "web_vitals": bool(team.autocapture_web_vitals_opt_in),
+                    "web_vitals_allowed_metrics": team.autocapture_web_vitals_allowed_metrics,
+                }
+                if team.capture_performance_opt_in or team.autocapture_web_vitals_opt_in
+                else False
+            ),
+            "autocapture_opt_out": bool(team.autocapture_opt_out),
+            "autocaptureExceptions": (
+                {
+                    "endpoint": "/e/",
+                }
+                if team.autocapture_exceptions_opt_in
+                else False
+            ),
+        }
+
+        if str(team.id) not in (settings.NEW_ANALYTICS_CAPTURE_EXCLUDED_TEAM_IDS or []):
+            config["analytics"] = {"endpoint": settings.NEW_ANALYTICS_CAPTURE_ENDPOINT}
+
+        if str(team.id) not in (settings.ELEMENT_CHAIN_AS_STRING_EXCLUDED_TEAMS or []):
+            config["elementsChainAsString"] = True
+
+        # MARK: Session Recording
+        session_recording_config_response: bool | dict = False
+
+        # TODO: Support the domain based check for recordings (maybe do it client side)?
+        if team.session_recording_opt_in:
+            capture_console_logs = True if team.capture_console_log_opt_in else False
+            sample_rate = str(team.session_recording_sample_rate) if team.session_recording_sample_rate else None
+
+            if sample_rate == "1.00":
+                sample_rate = None
+
+            minimum_duration = team.session_recording_minimum_duration_milliseconds or None
+
+            linked_flag = None
+            linked_flag_config = team.session_recording_linked_flag or None
+            if isinstance(linked_flag_config, dict):
+                linked_flag_key = linked_flag_config.get("key", None)
+                linked_flag_variant = linked_flag_config.get("variant", None)
+                if linked_flag_variant is not None:
+                    linked_flag = {"flag": linked_flag_key, "variant": linked_flag_variant}
+                else:
+                    linked_flag = linked_flag_key
+
+            rrweb_script_config = None
+
+            if (settings.SESSION_REPLAY_RRWEB_SCRIPT is not None) and (
+                "*" in settings.SESSION_REPLAY_RRWEB_SCRIPT_ALLOWED_TEAMS
+                or str(team.id) in settings.SESSION_REPLAY_RRWEB_SCRIPT_ALLOWED_TEAMS
+            ):
+                rrweb_script_config = {
+                    "script": settings.SESSION_REPLAY_RRWEB_SCRIPT,
+                }
+
+            session_recording_config_response = {
+                "endpoint": "/s/",
+                "consoleLogRecordingEnabled": capture_console_logs,
+                "recorderVersion": "v2",
+                "sampleRate": sample_rate,
+                "minimumDurationMilliseconds": minimum_duration,
+                "linkedFlag": linked_flag,
+                "networkPayloadCapture": team.session_recording_network_payload_capture_config or None,
+                "urlTriggers": team.session_recording_url_trigger_config,
+                "urlBlocklist": team.session_recording_url_blocklist_config,
+                "eventTriggers": team.session_recording_event_trigger_config,
+                "scriptConfig": rrweb_script_config,
+                # NOTE: This is cached but stripped out at the api level depending on the caller
+                "domains": team.recording_domains or [],
+            }
+
+            if isinstance(team.session_replay_config, dict):
+                record_canvas = team.session_replay_config.get("record_canvas", False)
+                session_recording_config_response.update(
+                    {
+                        "recordCanvas": record_canvas,
+                        # hard coded during beta while we decide on sensible values
+                        "canvasFps": 3 if record_canvas else None,
+                        "canvasQuality": "0.4" if record_canvas else None,
+                    }
+                )
+
+        config["sessionRecording"] = session_recording_config_response
+
+        # MARK: Quota limiting
+        if settings.EE_AVAILABLE:
+            from ee.billing.quota_limiting import (
+                QuotaLimitingCaches,
+                QuotaResource,
+                list_limited_team_attributes,
+            )
+
+            limited_tokens_recordings = list_limited_team_attributes(
+                QuotaResource.RECORDINGS, QuotaLimitingCaches.QUOTA_LIMITER_CACHE_KEY
+            )
+
+            if team.api_token in limited_tokens_recordings:
+                config["quotaLimited"] = ["recordings"]
+                config["sessionRecording"] = False
+
+        config["heatmaps"] = True if team.heatmaps_opt_in else False
+        surveys_response = get_surveys_response(team)
+        config["surveys"] = surveys_response["surveys"]
+        if surveys_response["survey_config"]:
+            config["survey_config"] = surveys_response["survey_config"]
+
+        config["defaultIdentifiedOnly"] = True  # Support old SDK versions with setting that is now the default
+
+        # MARK: Site apps - we want to eventually inline the JS but that will come later
+        site_apps = []
+        if team.inject_web_apps:
+            try:
+                with execute_with_timeout(200, DATABASE_FOR_FLAG_MATCHING):
+                    site_apps = get_decide_site_apps(team, using_database=DATABASE_FOR_FLAG_MATCHING)
+            except Exception:
+                pass
+
+        config["siteApps"] = site_apps
+
+        # Array of JS objects to be included when building the final JS
+        config["siteAppsJS"] = self._build_site_apps_js()
+
+        return config
+
+    def _build_site_apps_js(self):
+        # NOTE: This is the web focused config for the frontend that includes site apps
+
+        from posthog.plugins.site import get_site_apps_for_team, get_site_config_from_schema
+        from posthog.cdp.site_functions import get_transpiled_function
+        from posthog.models import HogFunction
+
+        # Add in the site apps as an array of objects
+        site_apps_js = []
+        for site_app in get_site_apps_for_team(self.team.id):
+            config = get_site_config_from_schema(site_app.config_schema, site_app.config)
+            site_apps_js.append(
+                indent_js(
+                    f"\n{{\n  id: '{site_app.token}',\n  init: function(config) {{\n    {indent_js(site_app.source, indent=4)}().inject({{ config:{json.dumps(config)}, posthog:config.posthog }});\n    config.callback();\n  }}\n}}"
+                )
+            )
+        site_functions = (
+            HogFunction.objects.select_related("team")
+            .filter(team=self.team, enabled=True, type__in=("site_destination", "site_app"))
+            .all()
+        )
+
+        site_functions_js = []
+
+        for site_function in site_functions:
+            try:
+                source = get_transpiled_function(site_function)
+                # NOTE: It is an object as we can later add other properties such as a consent ID
+                # Indentation to make it more readable (and therefore debuggable)
+                site_functions_js.append(
+                    indent_js(
+                        f"\n{{\n  id: '{site_function.id}',\n  init: function(config) {{ return {indent_js(source, indent=4)}().init(config) }} \n}}"
+                    )
+                )
+            except Exception:
+                # TODO: Should we track this to somewhere?
+                logger.exception(f"Failed to build JS for site function {site_function.id}")
+                pass
+
+        return site_apps_js + site_functions_js
+
+    @classmethod
+    def _get_via_cache(
+        cls, token: str, suffix: str, fn: Callable[["RemoteConfig"], dict | str], timeout: int = CACHE_TIMEOUT
+    ) -> Any:
+        key = cache_key_for_team_token(token, suffix)
+
+        data = cache.get(key)
+        if data == "404":
+            REMOTE_CONFIG_CACHE_COUNTER.labels(result="hit_but_missing").inc()
+            raise cls.DoesNotExist()
+
+        if data:
+            REMOTE_CONFIG_CACHE_COUNTER.labels(result="hit").inc()
+            return data
+
+        REMOTE_CONFIG_CACHE_COUNTER.labels(result="miss").inc()
+        try:
+            remote_config = cls.objects.select_related("team").get(team__api_token=token)
+        except cls.DoesNotExist:
+            cache.set(key, "404", timeout=timeout)
+            REMOTE_CONFIG_CACHE_COUNTER.labels(result="miss_but_missing").inc()
+            raise
+
+        data = fn(remote_config)
+        cache.set(key, data, timeout=timeout)
+
+        return data
+
+    @classmethod
+    def get_config_via_token(cls, token: str, request: Optional[HttpRequest] = None) -> dict:
+        config = cls._get_via_cache(token, "config", lambda remote_config: remote_config.build_config())
+        config = sanitize_config_for_public_cdn(config, request=request)
+
+        return config
+
+    @classmethod
+    def get_config_js_via_token(cls, token: str, request: Optional[HttpRequest] = None) -> str:
+        config = cls._get_via_cache(token, "config", lambda remote_config: remote_config.build_config())
+        # Get the site apps JS so we can render it in the JS
+        site_apps_js = config.pop("siteAppsJS", None)
+        # We don't want to include the minimal site apps content as we have the JS now
+        config.pop("siteApps", None)
+        config = sanitize_config_for_public_cdn(config, request=request)
+
+        js_content = f"""(function() {{
+  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {{}};
+  window._POSTHOG_REMOTE_CONFIG['{token}'] = {{
+    config: {json.dumps(config)},
+    siteApps: [{','.join(site_apps_js)}]
+  }}
+}})();
+        """.strip()
+
+        return js_content
+
+    @classmethod
+    def get_array_js_via_token(cls, token: str, request: Optional[HttpRequest] = None) -> str:
+        # NOTE: Unlike the other methods we dont store this in the cache as it is cheap to build at runtime
+        js_content = cls.get_config_js_via_token(token, request=request)
+
+        return f"""{get_array_js_content()}\n\n{js_content}"""
+
+    def sync(self):
+        """
+        When called we sync to any configured CDNs as well as redis for the /decide endpoint
+        """
+
+        logger.info(f"Syncing RemoteConfig for team {self.team_id}")
+
+        try:
+            config = self.build_config()
+            self.config = config
+
+            cache.set(cache_key_for_team_token(self.team.api_token, "config"), config, timeout=CACHE_TIMEOUT)
+
+            self._purge_cdn()
+
+            # TODO: Invalidate caches - in particular this will be the Cloudflare CDN cache
+            self.synced_at = timezone.now()
+            self.save()
+
+            CELERY_TASK_REMOTE_CONFIG_SYNC.labels(result="success").inc()
+        except Exception as e:
+            capture_exception(e)
+            logger.exception(f"Failed to sync RemoteConfig for team {self.team_id}", exception=str(e))
+            CELERY_TASK_REMOTE_CONFIG_SYNC.labels(result="failure").inc()
+            raise
+
+    def _purge_cdn(self):
+        if (
+            not settings.REMOTE_CONFIG_CDN_PURGE_ENDPOINT
+            or not settings.REMOTE_CONFIG_CDN_PURGE_TOKEN
+            or not settings.REMOTE_CONFIG_CDN_PURGE_DOMAINS
+        ):
+            return
+
+        data: dict[str, Any] = {"files": []}
+
+        for domain in settings.REMOTE_CONFIG_CDN_PURGE_DOMAINS:
+            # Check if the domain starts with https:// and if not add it
+            full_domain = domain if domain.startswith("https://") else f"https://{domain}"
+            data["files"].append({"url": f"{full_domain}/array/{self.team.api_token}/config"})
+            data["files"].append({"url": f"{full_domain}/array/{self.team.api_token}/config.js"})
+            data["files"].append({"url": f"{full_domain}/array/{self.team.api_token}/array.js"})
+
+        logger.info(f"Purging CDN for team {self.team_id}", {"data": data})
+
+        try:
+            res = requests.post(
+                settings.REMOTE_CONFIG_CDN_PURGE_ENDPOINT,
+                headers={"Authorization": f"Bearer {settings.REMOTE_CONFIG_CDN_PURGE_TOKEN}"},
+                json=data,
+            )
+
+            if res.status_code != 200:
+                raise Exception(f"Failed to purge CDN for team {self.team_id}: {res.status_code} {res.text}")
+
+        except Exception:
+            logger.exception(f"Failed to purge CDN for team {self.team_id}")
+            REMOTE_CONFIG_CDN_PURGE_COUNTER.labels(result="failure").inc()
+        else:
+            REMOTE_CONFIG_CDN_PURGE_COUNTER.labels(result="success").inc()
+
+    def __str__(self):
+        return f"RemoteConfig {self.team_id}"
+
+
+def _update_team_remote_config(team_id: int):
+    from posthog.tasks.remote_config import update_team_remote_config
+
+    update_team_remote_config.delay(team_id)
+
+
+@receiver(post_save, sender=Team)
+def team_saved(sender, instance: "Team", created, **kwargs):
+    _update_team_remote_config(instance.id)
+
+
+@receiver(post_save, sender=FeatureFlag)
+def feature_flag_saved(sender, instance: "FeatureFlag", created, **kwargs):
+    _update_team_remote_config(instance.team_id)
+
+
+@receiver(post_save, sender=PluginConfig)
+def site_app_saved(sender, instance: "PluginConfig", created, **kwargs):
+    if instance.team_id:
+        _update_team_remote_config(instance.team_id)
+
+
+@receiver(post_save, sender=HogFunction)
+def site_function_saved(sender, instance: "HogFunction", created, **kwargs):
+    if instance.enabled and instance.type in ("site_destination", "site_app"):
+        _update_team_remote_config(instance.team_id)
+
+
+@receiver(post_save, sender=Survey)
+def survey_saved(sender, instance: "Survey", created, **kwargs):
+    _update_team_remote_config(instance.team_id)
diff --git a/posthog/models/team/team.py b/posthog/models/team/team.py
index b87ed07c84ee0..40bea6d9e089c 100644
--- a/posthog/models/team/team.py
+++ b/posthog/models/team/team.py
@@ -519,7 +519,7 @@ def __str__(self):
             return ", ".join(self.app_urls)
         return str(self.pk)
 
-    __repr__ = sane_repr("uuid", "name", "api_token")
+    __repr__ = sane_repr("id", "uuid", "project_id", "name", "api_token")
 
 
 @mutable_receiver(post_save, sender=Team)
diff --git a/posthog/models/team/team_caching.py b/posthog/models/team/team_caching.py
index 78042111a824c..66309bd9399e2 100644
--- a/posthog/models/team/team_caching.py
+++ b/posthog/models/team/team_caching.py
@@ -38,6 +38,8 @@ def get_team_in_cache(token: str) -> Optional["Team"]:
     if team_data:
         try:
             parsed_data = json.loads(team_data)
+            if "project_id" not in parsed_data:
+                parsed_data["project_id"] = parsed_data["id"]
             return Team(**parsed_data)
         except Exception as e:
             capture_exception(e)
diff --git a/posthog/models/team/util.py b/posthog/models/team/util.py
index 5756c8da211aa..5cb103b154b84 100644
--- a/posthog/models/team/util.py
+++ b/posthog/models/team/util.py
@@ -14,10 +14,12 @@ def delete_bulky_postgres_data(team_ids: list[int]):
     from posthog.models.feature_flag.feature_flag import FeatureFlagHashKeyOverride
     from posthog.models.insight_caching_state import InsightCachingState
     from posthog.models.person import Person, PersonDistinctId
+    from posthog.models.error_tracking import ErrorTrackingIssueFingerprintV2
     from posthog.models.early_access_feature import EarlyAccessFeature
 
     _raw_delete(EarlyAccessFeature.objects.filter(team_id__in=team_ids))
     _raw_delete(PersonDistinctId.objects.filter(team_id__in=team_ids))
+    _raw_delete(ErrorTrackingIssueFingerprintV2.objects.filter(team_id__in=team_ids))
     _raw_delete(CohortPeople.objects.filter(cohort__team_id__in=team_ids))
     _raw_delete(FeatureFlagHashKeyOverride.objects.filter(team_id__in=team_ids))
     _raw_delete(Person.objects.filter(team_id__in=team_ids))
diff --git a/posthog/models/test/test_async_deletion_model.py b/posthog/models/test/test_async_deletion_model.py
index 8f4125be67a3c..e5649d6e812d9 100644
--- a/posthog/models/test/test_async_deletion_model.py
+++ b/posthog/models/test/test_async_deletion_model.py
@@ -365,7 +365,7 @@ def test_delete_auxilary_models_via_team(self):
             group_key="org:5",
             properties={},
         )
-        insert_static_cohort([uuid4()], 0, self.teams[0])
+        insert_static_cohort([uuid4()], 0, team_id=self.teams[0].pk)
         self._insert_cohortpeople_row(self.teams[0], uuid4(), 3)
         create_plugin_log_entry(
             team_id=self.teams[0].pk,
@@ -403,7 +403,7 @@ def test_delete_auxilary_models_via_team_unrelated(self):
             group_key="org:5",
             properties={},
         )
-        insert_static_cohort([uuid4()], 0, self.teams[1])
+        insert_static_cohort([uuid4()], 0, team_id=self.teams[1].pk)
         self._insert_cohortpeople_row(self.teams[1], uuid4(), 3)
         create_plugin_log_entry(
             team_id=self.teams[1].pk,
diff --git a/posthog/models/test/test_hog_function.py b/posthog/models/test/test_hog_function.py
index bfbfa7e6f74cd..49d0ea9f27564 100644
--- a/posthog/models/test/test_hog_function.py
+++ b/posthog/models/test/test_hog_function.py
@@ -275,7 +275,8 @@ def test_hog_functions_reload_on_team_saved(self):
             {"key": "$pageview", "operator": "regex", "value": "test"},
         ]
         # 1 update team, 1 load hog functions, 1 update hog functions
-        with self.assertNumQueries(3):
+        # 8 unrelated due to RemoteConfig refresh
+        with self.assertNumQueries(3 + 8):
             self.team.save()
         hog_function_1.refresh_from_db()
         hog_function_2.refresh_from_db()
diff --git a/posthog/models/test/test_integration_model.py b/posthog/models/test/test_integration_model.py
index 456f085d9c2e9..d4184d9e0265a 100644
--- a/posthog/models/test/test_integration_model.py
+++ b/posthog/models/test/test_integration_model.py
@@ -120,7 +120,7 @@ def test_authorize_url_with_additional_authorize_params(self):
             url = OauthIntegration.authorize_url("google-ads", next="/projects/test")
             assert (
                 url
-                == "https://accounts.google.com/o/oauth2/v2/auth?client_id=google-client-id&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fadwords+email&redirect_uri=https%3A%2F%2Flocalhost%3A8000%2Fintegrations%2Fgoogle-ads%2Fcallback&response_type=code&state=next%3D%252Fprojects%252Ftest&access_type=offline&prompt=consent"
+                == "https://accounts.google.com/o/oauth2/v2/auth?client_id=google-client-id&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fadwords+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fuserinfo.email&redirect_uri=https%3A%2F%2Flocalhost%3A8000%2Fintegrations%2Fgoogle-ads%2Fcallback&response_type=code&state=next%3D%252Fprojects%252Ftest&access_type=offline&prompt=consent"
             )
 
     @patch("posthog.models.integration.requests.post")
@@ -199,6 +199,10 @@ def test_integration_fetches_info_from_token_info_url(self, mock_get, mock_post)
                 "user": "user",
                 "user_id": "user_id",
                 "should_not": "be_saved",
+                "scopes": [
+                    "crm.objects.contacts.read",
+                    "crm.objects.contacts.write",
+                ],
             }
 
             with freeze_time("2024-01-01T12:00:00Z"):
@@ -219,6 +223,10 @@ def test_integration_fetches_info_from_token_info_url(self, mock_get, mock_post)
                 "user": "user",
                 "user_id": "user_id",
                 "refreshed_at": 1704110400,
+                "scopes": [
+                    "crm.objects.contacts.read",
+                    "crm.objects.contacts.write",
+                ],
             }
             assert integration.sensitive_config == {
                 "access_token": "FAKES_ACCESS_TOKEN",
diff --git a/posthog/models/test/test_product_intent.py b/posthog/models/test/test_product_intent.py
index 81b05f2326921..469f8d4845567 100644
--- a/posthog/models/test/test_product_intent.py
+++ b/posthog/models/test/test_product_intent.py
@@ -1,8 +1,11 @@
-from datetime import datetime, timedelta, UTC
+from datetime import UTC, datetime, timedelta
 
 import pytest
 from freezegun import freeze_time
 
+from posthog.models.experiment import Experiment
+from posthog.models.feature_flag import FeatureFlag
+from posthog.models.feedback.survey import Survey
 from posthog.models.insight import Insight
 from posthog.models.product_intent.product_intent import (
     ProductIntent,
@@ -93,3 +96,77 @@ def test_calculate_product_activation_skips_activated_products(self):
             calculate_product_activation(self.team.id)
             self.product_intent.refresh_from_db()
             assert self.product_intent.activated_at == datetime(2024, 6, 15, 12, 0, 0, tzinfo=UTC)
+
+    def test_has_activated_experiments_with_launched_experiment(self):
+        self.product_intent.product_type = "experiments"
+        self.product_intent.save()
+
+        # Create a feature flag for the experiment
+        feature_flag = FeatureFlag.objects.create(
+            team=self.team,
+            key="test-flag",
+            name="Test Flag",
+            filters={"groups": [{"properties": []}]},
+        )
+
+        # Create an experiment without a start date (not launched)
+        Experiment.objects.create(team=self.team, name="Not launched", feature_flag=feature_flag)
+        self.assertFalse(self.product_intent.has_activated_experiments())
+
+        # Create another feature flag for the launched experiment
+        launched_flag = FeatureFlag.objects.create(
+            team=self.team,
+            key="launched-flag",
+            name="Launched Flag",
+            filters={"groups": [{"properties": []}]},
+        )
+
+        # Create an experiment with a start date (launched)
+        Experiment.objects.create(
+            team=self.team, name="Launched", start_date=datetime.now(tz=UTC), feature_flag=launched_flag
+        )
+        self.assertTrue(self.product_intent.has_activated_experiments())
+
+    def test_has_activated_feature_flags(self):
+        self.product_intent.product_type = "feature_flags"
+        self.product_intent.save()
+
+        # Create a feature flag with one filter group
+        FeatureFlag.objects.create(
+            team=self.team,
+            key="flag-1",
+            name="Flag 1",
+            filters={"groups": [{"properties": [{"key": "email", "value": "test@test.com"}]}]},
+        )
+        self.assertFalse(self.product_intent.has_activated_feature_flags())
+
+        # Create a feature flag with another filter group
+        FeatureFlag.objects.create(
+            team=self.team,
+            key="flag-2",
+            name="Flag 2",
+            filters={"groups": [{"properties": [{"key": "country", "value": "US"}]}]},
+        )
+        self.assertTrue(self.product_intent.has_activated_feature_flags())
+
+    def test_has_activated_feature_flags_excludes_experiment_and_survey_flags(self):
+        self.product_intent.product_type = "feature_flags"
+        self.product_intent.save()
+
+        # Create excluded feature flags
+        feature_flag = FeatureFlag.objects.create(
+            team=self.team,
+            key="feature-flag-for-experiment-test",
+            name="Feature Flag for Experiment Test",
+            filters={"groups": [{"properties": [{"key": "email", "value": "test@test.com"}]}]},
+        )
+        Experiment.objects.create(team=self.team, name="Experiment Test", feature_flag=feature_flag)
+        survey_flag = FeatureFlag.objects.create(
+            team=self.team,
+            key="targeting-flag-for-survey-test",
+            name="Targeting flag for survey Test",
+            filters={"groups": [{"properties": [{"key": "country", "value": "US"}]}]},
+        )
+        Survey.objects.create(team=self.team, name="Survey Test", targeting_flag=survey_flag)
+
+        self.assertFalse(self.product_intent.has_activated_feature_flags())
diff --git a/posthog/models/test/test_remote_config.py b/posthog/models/test/test_remote_config.py
new file mode 100644
index 0000000000000..e90e3a9edd580
--- /dev/null
+++ b/posthog/models/test/test_remote_config.py
@@ -0,0 +1,800 @@
+from decimal import Decimal
+from unittest.mock import patch
+from django.test import RequestFactory
+from inline_snapshot import snapshot
+import pytest
+from posthog.models.action.action import Action
+from posthog.models.feature_flag.feature_flag import FeatureFlag
+from posthog.models.feedback.survey import Survey
+from posthog.models.hog_functions.hog_function import HogFunction, HogFunctionType
+from posthog.models.plugin import Plugin, PluginConfig, PluginSourceFile
+from posthog.models.project import Project
+from posthog.models.remote_config import RemoteConfig, cache_key_for_team_token
+from posthog.test.base import BaseTest
+from django.core.cache import cache
+
+CONFIG_REFRESH_QUERY_COUNT = 5
+
+
+class _RemoteConfigBase(BaseTest):
+    remote_config: RemoteConfig
+
+    def setUp(self):
+        super().setUp()
+
+        project, team = Project.objects.create_with_team(
+            initiating_user=self.user,
+            organization=self.organization,
+            name="Test project",
+        )
+        self.team = team
+        self.team.api_token = "phc_12345"  # Easier to test against
+        self.team.recording_domains = ["https://*.example.com"]
+        self.team.session_recording_opt_in = True
+        self.team.save()
+
+        # There will always be a config thanks to the signal
+        self.remote_config = RemoteConfig.objects.get(team=self.team)
+
+
+class TestRemoteConfig(_RemoteConfigBase):
+    def test_creates_remote_config_immediately(self):
+        assert self.remote_config
+        assert self.remote_config.updated_at
+        assert self.remote_config.synced_at
+
+        assert self.remote_config.config == snapshot(
+            {
+                "token": "phc_12345",
+                "surveys": [],
+                "heatmaps": False,
+                "siteApps": [],
+                "analytics": {"endpoint": "/i/v0/e/"},
+                "siteAppsJS": [],
+                "hasFeatureFlags": False,
+                "sessionRecording": {
+                    "domains": ["https://*.example.com"],
+                    "endpoint": "/s/",
+                    "linkedFlag": None,
+                    "sampleRate": None,
+                    "urlTriggers": [],
+                    "scriptConfig": None,
+                    "urlBlocklist": [],
+                    "eventTriggers": [],
+                    "recorderVersion": "v2",
+                    "networkPayloadCapture": None,
+                    "consoleLogRecordingEnabled": True,
+                    "minimumDurationMilliseconds": None,
+                },
+                "captureDeadClicks": False,
+                "capturePerformance": {"web_vitals": False, "network_timing": True, "web_vitals_allowed_metrics": None},
+                "autocapture_opt_out": False,
+                "supportedCompression": ["gzip", "gzip-js"],
+                "autocaptureExceptions": False,
+                "defaultIdentifiedOnly": True,
+                "elementsChainAsString": True,
+            }
+        )
+
+    def test_indicates_if_feature_flags_exist(self):
+        assert not self.remote_config.config["hasFeatureFlags"]
+
+        flag = FeatureFlag.objects.create(
+            team=self.team,
+            filters={},
+            name="TestFlag",
+            key="test-flag",
+            created_by=self.user,
+            deleted=True,
+        )
+
+        assert not self.remote_config.config["hasFeatureFlags"]
+        flag.active = False
+        flag.deleted = False
+        flag.save()
+        self.remote_config.refresh_from_db()
+        assert not self.remote_config.config["hasFeatureFlags"]
+        flag.active = True
+        flag.deleted = False
+        flag.save()
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["hasFeatureFlags"]
+
+    def test_capture_dead_clicks_toggle(self):
+        self.team.capture_dead_clicks = True
+        self.team.save()
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["captureDeadClicks"]
+
+    def test_capture_performance_toggle(self):
+        self.team.capture_performance_opt_in = True
+        self.team.save()
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["capturePerformance"]["network_timing"]
+
+    def test_autocapture_opt_out_toggle(self):
+        self.team.autocapture_opt_out = True
+        self.team.save()
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["autocapture_opt_out"]
+
+    def test_autocapture_exceptions_toggle(self):
+        self.team.autocapture_exceptions_opt_in = True
+        self.team.save()
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["autocaptureExceptions"] == {"endpoint": "/e/"}
+
+    def test_session_recording_sample_rate(self):
+        self.team.session_recording_opt_in = True
+        self.team.session_recording_sample_rate = Decimal("0.5")
+        self.team.save()
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["sessionRecording"]["sampleRate"] == "0.50"
+
+    def test_session_recording_domains(self):
+        self.team.session_recording_opt_in = True
+        self.team.recording_domains = ["https://posthog.com", "https://*.posthog.com"]
+        self.team.save()
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["sessionRecording"]["domains"] == self.team.recording_domains
+
+
+class TestRemoteConfigSurveys(_RemoteConfigBase):
+    # Largely copied from TestSurveysAPIList
+    def setUp(self):
+        super().setUp()
+
+        self.team.save()
+
+    def test_includes_survey_config(self):
+        survey_appearance = {
+            "thankYouMessageHeader": "Thanks for your feedback!",
+            "thankYouMessageDescription": "We'll use it to make notebooks better",
+        }
+
+        self.team.survey_config = {"appearance": survey_appearance}
+        self.team.save()
+
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["survey_config"] == snapshot(
+            {
+                "appearance": {
+                    "thankYouMessageHeader": "Thanks for your feedback!",
+                    "thankYouMessageDescription": "We'll use it to make notebooks better",
+                }
+            }
+        )
+
+    def test_includes_range_of_survey_types(self):
+        survey_basic = Survey.objects.create(
+            team=self.team,
+            created_by=self.user,
+            name="Basic survey",
+            description="This should not be included",
+            type="popover",
+            questions=[{"type": "open", "question": "What's a survey?"}],
+        )
+        linked_flag = FeatureFlag.objects.create(team=self.team, key="linked-flag", created_by=self.user)
+        targeting_flag = FeatureFlag.objects.create(team=self.team, key="targeting-flag", created_by=self.user)
+        internal_targeting_flag = FeatureFlag.objects.create(
+            team=self.team, key="custom-targeting-flag", created_by=self.user
+        )
+
+        survey_with_flags = Survey.objects.create(
+            team=self.team,
+            created_by=self.user,
+            name="Survey with flags",
+            type="popover",
+            linked_flag=linked_flag,
+            targeting_flag=targeting_flag,
+            internal_targeting_flag=internal_targeting_flag,
+            questions=[{"type": "open", "question": "What's a hedgehog?"}],
+        )
+
+        action = Action.objects.create(
+            team=self.team,
+            name="user subscribed",
+            steps_json=[{"event": "$pageview", "url": "docs", "url_matching": "contains"}],
+        )
+
+        survey_with_actions = Survey.objects.create(
+            team=self.team,
+            created_by=self.user,
+            name="survey with actions",
+            type="popover",
+            questions=[{"type": "open", "question": "Why's a hedgehog?"}],
+        )
+        survey_with_actions.actions.set(Action.objects.filter(name="user subscribed"))
+        survey_with_actions.save()
+
+        self.remote_config.refresh_from_db()
+        assert self.remote_config.config["surveys"]
+        assert self.remote_config.config["surveys"] == [
+            {
+                "id": str(survey_basic.id),
+                "name": "Basic survey",
+                "type": "popover",
+                "end_date": None,
+                "questions": [{"type": "open", "question": "What's a survey?"}],
+                "appearance": None,
+                "conditions": None,
+                "start_date": None,
+                "current_iteration": None,
+                "current_iteration_start_date": None,
+            },
+            {
+                "id": str(survey_with_flags.id),
+                "name": "Survey with flags",
+                "type": "popover",
+                "end_date": None,
+                "questions": [{"type": "open", "question": "What's a hedgehog?"}],
+                "appearance": None,
+                "conditions": None,
+                "start_date": None,
+                "linked_flag_key": "linked-flag",
+                "current_iteration": None,
+                "targeting_flag_key": "targeting-flag",
+                "internal_targeting_flag_key": "custom-targeting-flag",
+                "current_iteration_start_date": None,
+            },
+            {
+                "id": str(survey_with_actions.id),
+                "name": "survey with actions",
+                "type": "popover",
+                "end_date": None,
+                "questions": [{"type": "open", "question": "Why's a hedgehog?"}],
+                "appearance": None,
+                "conditions": {
+                    "actions": {
+                        "values": [
+                            {
+                                "id": action.id,
+                                "name": "user subscribed",
+                                "steps": [
+                                    {
+                                        "url": "docs",
+                                        "href": None,
+                                        "text": None,
+                                        "event": "$pageview",
+                                        "selector": None,
+                                        "tag_name": None,
+                                        "properties": None,
+                                        "url_matching": "contains",
+                                        "href_matching": None,
+                                        "text_matching": None,
+                                    }
+                                ],
+                            }
+                        ]
+                    }
+                },
+                "start_date": None,
+                "current_iteration": None,
+                "current_iteration_start_date": None,
+            },
+        ]
+
+
+class TestRemoteConfigCaching(_RemoteConfigBase):
+    def setUp(self):
+        super().setUp()
+        self.remote_config.refresh_from_db()
+        # Clear the cache so we are properly testing each flow
+        assert cache.delete(cache_key_for_team_token(self.team.api_token, "config"))
+
+    def _assert_matches_config(self, data):
+        assert data == snapshot(
+            {
+                "token": "phc_12345",
+                "supportedCompression": ["gzip", "gzip-js"],
+                "hasFeatureFlags": False,
+                "captureDeadClicks": False,
+                "capturePerformance": {"network_timing": True, "web_vitals": False, "web_vitals_allowed_metrics": None},
+                "autocapture_opt_out": False,
+                "autocaptureExceptions": False,
+                "analytics": {"endpoint": "/i/v0/e/"},
+                "elementsChainAsString": True,
+                "sessionRecording": {
+                    "endpoint": "/s/",
+                    "consoleLogRecordingEnabled": True,
+                    "recorderVersion": "v2",
+                    "sampleRate": None,
+                    "minimumDurationMilliseconds": None,
+                    "linkedFlag": None,
+                    "networkPayloadCapture": None,
+                    "urlTriggers": [],
+                    "urlBlocklist": [],
+                    "eventTriggers": [],
+                    "scriptConfig": None,
+                },
+                "heatmaps": False,
+                "surveys": [],
+                "defaultIdentifiedOnly": True,
+                "siteApps": [],
+            }
+        )
+
+    def _assert_matches_config_js(self, data):
+        assert data == snapshot(
+            """\
+(function() {
+  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {};
+  window._POSTHOG_REMOTE_CONFIG['phc_12345'] = {
+    config: {"token": "phc_12345", "supportedCompression": ["gzip", "gzip-js"], "hasFeatureFlags": false, "captureDeadClicks": false, "capturePerformance": {"network_timing": true, "web_vitals": false, "web_vitals_allowed_metrics": null}, "autocapture_opt_out": false, "autocaptureExceptions": false, "analytics": {"endpoint": "/i/v0/e/"}, "elementsChainAsString": true, "sessionRecording": {"endpoint": "/s/", "consoleLogRecordingEnabled": true, "recorderVersion": "v2", "sampleRate": null, "minimumDurationMilliseconds": null, "linkedFlag": null, "networkPayloadCapture": null, "urlTriggers": [], "urlBlocklist": [], "eventTriggers": [], "scriptConfig": null}, "heatmaps": false, "surveys": [], "defaultIdentifiedOnly": true},
+    siteApps: []
+  }
+})();\
+"""
+        )
+
+    def _assert_matches_config_array_js(self, data):
+        assert data == snapshot(
+            """\
+[MOCKED_ARRAY_JS_CONTENT]
+
+(function() {
+  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {};
+  window._POSTHOG_REMOTE_CONFIG['phc_12345'] = {
+    config: {"token": "phc_12345", "supportedCompression": ["gzip", "gzip-js"], "hasFeatureFlags": false, "captureDeadClicks": false, "capturePerformance": {"network_timing": true, "web_vitals": false, "web_vitals_allowed_metrics": null}, "autocapture_opt_out": false, "autocaptureExceptions": false, "analytics": {"endpoint": "/i/v0/e/"}, "elementsChainAsString": true, "sessionRecording": {"endpoint": "/s/", "consoleLogRecordingEnabled": true, "recorderVersion": "v2", "sampleRate": null, "minimumDurationMilliseconds": null, "linkedFlag": null, "networkPayloadCapture": null, "urlTriggers": [], "urlBlocklist": [], "eventTriggers": [], "scriptConfig": null}, "heatmaps": false, "surveys": [], "defaultIdentifiedOnly": true},
+    siteApps: []
+  }
+})();\
+"""
+        )
+
+    def test_syncs_if_changes(self):
+        synced_at = self.remote_config.synced_at
+        self.remote_config.config["surveys"] = True
+        self.remote_config.sync()
+        assert synced_at < self.remote_config.synced_at  # type: ignore
+
+    def test_persists_data_to_redis_on_sync(self):
+        self.remote_config.config["surveys"] = True
+        self.remote_config.sync()
+        assert cache.get(cache_key_for_team_token(self.team.api_token, "config"))
+
+    def test_gets_via_redis_cache(self):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            data = RemoteConfig.get_config_via_token(self.team.api_token)
+            self._assert_matches_config(data)
+
+        with self.assertNumQueries(0):
+            data = RemoteConfig.get_config_via_token(self.team.api_token)
+            self._assert_matches_config(data)
+
+    def test_gets_js_via_redis_cache(self):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            data = RemoteConfig.get_config_js_via_token(self.team.api_token)
+            self._assert_matches_config_js(data)
+
+        with self.assertNumQueries(0):
+            data = RemoteConfig.get_config_js_via_token(self.team.api_token)
+            self._assert_matches_config_js(data)
+
+    def test_gets_js_reuses_config_cache(self):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            RemoteConfig.get_config_via_token(self.team.api_token)
+
+        with self.assertNumQueries(0):
+            data = RemoteConfig.get_config_js_via_token(self.team.api_token)
+            self._assert_matches_config_js(data)
+
+    @patch("posthog.models.remote_config.get_array_js_content", return_value="[MOCKED_ARRAY_JS_CONTENT]")
+    def test_gets_array_js_via_redis_cache(self, mock_get_array_js_content):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            data = RemoteConfig.get_array_js_via_token(self.team.api_token)
+            self._assert_matches_config_array_js(data)
+
+        with self.assertNumQueries(0):
+            data = RemoteConfig.get_array_js_via_token(self.team.api_token)
+            self._assert_matches_config_array_js(data)
+
+    def test_caches_missing_response(self):
+        with self.assertNumQueries(1):
+            with pytest.raises(RemoteConfig.DoesNotExist):
+                RemoteConfig.get_array_js_via_token("missing-token")
+
+        with self.assertNumQueries(0):
+            with pytest.raises(RemoteConfig.DoesNotExist):
+                RemoteConfig.get_array_js_via_token("missing-token")
+
+    def test_sanitizes_config_for_public_cdn(self):
+        config = self.remote_config.get_config_via_token(self.team.api_token)
+        # Ensure the domain and siteAppsJS are removed
+        assert config == snapshot(
+            {
+                "token": "phc_12345",
+                "supportedCompression": ["gzip", "gzip-js"],
+                "hasFeatureFlags": False,
+                "captureDeadClicks": False,
+                "capturePerformance": {"network_timing": True, "web_vitals": False, "web_vitals_allowed_metrics": None},
+                "autocapture_opt_out": False,
+                "autocaptureExceptions": False,
+                "analytics": {"endpoint": "/i/v0/e/"},
+                "elementsChainAsString": True,
+                "sessionRecording": {
+                    "endpoint": "/s/",
+                    "consoleLogRecordingEnabled": True,
+                    "recorderVersion": "v2",
+                    "sampleRate": None,
+                    "minimumDurationMilliseconds": None,
+                    "linkedFlag": None,
+                    "networkPayloadCapture": None,
+                    "urlTriggers": [],
+                    "urlBlocklist": [],
+                    "eventTriggers": [],
+                    "scriptConfig": None,
+                },
+                "heatmaps": False,
+                "surveys": [],
+                "defaultIdentifiedOnly": True,
+                "siteApps": [],
+            }
+        )
+
+    def test_only_includes_recording_for_approved_domains(self):
+        with self.assertNumQueries(CONFIG_REFRESH_QUERY_COUNT):
+            mock_request = RequestFactory().get("/")
+            mock_request.META["HTTP_ORIGIN"] = "https://my.example.com"
+            config = self.remote_config.get_config_via_token(self.team.api_token, request=mock_request)
+            assert config["sessionRecording"]
+
+        # No additional queries should be needed to check the other domain
+        with self.assertNumQueries(0):
+            mock_request = RequestFactory().get("/")
+            mock_request.META["HTTP_ORIGIN"] = "https://other.com"
+            config = self.remote_config.get_config_via_token(self.team.api_token, request=mock_request)
+            assert not config["sessionRecording"]
+
+    @patch("posthog.models.remote_config.requests.post")
+    def test_purges_cdn_cache_on_sync(self, mock_post):
+        with self.settings(
+            REMOTE_CONFIG_CDN_PURGE_ENDPOINT="https://api.cloudflare.com/client/v4/zones/MY_ZONE_ID/purge_cache",
+            REMOTE_CONFIG_CDN_PURGE_TOKEN="MY_TOKEN",
+            REMOTE_CONFIG_CDN_PURGE_DOMAINS=["cdn.posthog.com", "https://cdn2.posthog.com"],
+        ):
+            self.remote_config.sync()
+            mock_post.assert_called_once_with(
+                "https://api.cloudflare.com/client/v4/zones/MY_ZONE_ID/purge_cache",
+                headers={"Authorization": "Bearer MY_TOKEN"},
+                json={
+                    "files": [
+                        {"url": "https://cdn.posthog.com/array/phc_12345/config"},
+                        {"url": "https://cdn.posthog.com/array/phc_12345/config.js"},
+                        {"url": "https://cdn.posthog.com/array/phc_12345/array.js"},
+                        {"url": "https://cdn2.posthog.com/array/phc_12345/config"},
+                        {"url": "https://cdn2.posthog.com/array/phc_12345/config.js"},
+                        {"url": "https://cdn2.posthog.com/array/phc_12345/array.js"},
+                    ]
+                },
+            )
+
+
+class TestRemoteConfigJS(_RemoteConfigBase):
+    def test_renders_js_including_config(self):
+        # NOTE: This is a very basic test to check that the JS is rendered correctly
+        # It doesn't check the actual contents of the JS, as that changes often but checks some general things
+        js = self.remote_config.get_config_js_via_token(self.team.api_token)
+
+        # TODO: Come up with a good way of solidly testing this...
+        assert js == snapshot(
+            """\
+(function() {
+  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {};
+  window._POSTHOG_REMOTE_CONFIG['phc_12345'] = {
+    config: {"token": "phc_12345", "supportedCompression": ["gzip", "gzip-js"], "hasFeatureFlags": false, "captureDeadClicks": false, "capturePerformance": {"network_timing": true, "web_vitals": false, "web_vitals_allowed_metrics": null}, "autocapture_opt_out": false, "autocaptureExceptions": false, "analytics": {"endpoint": "/i/v0/e/"}, "elementsChainAsString": true, "sessionRecording": {"endpoint": "/s/", "consoleLogRecordingEnabled": true, "recorderVersion": "v2", "sampleRate": null, "minimumDurationMilliseconds": null, "linkedFlag": null, "networkPayloadCapture": null, "urlTriggers": [], "urlBlocklist": [], "eventTriggers": [], "scriptConfig": null}, "heatmaps": false, "surveys": [], "defaultIdentifiedOnly": true},
+    siteApps: []
+  }
+})();\
+"""
+        )
+
+    def test_renders_js_including_site_apps(self):
+        files = [
+            "(function () { return { inject: (data) => console.log('injected!', data)}; })",
+            "(function () { return { inject: (data) => console.log('injected 2!', data)}; })",
+            "(function () { return { inject: (data) => console.log('injected but disabled!', data)}; })",
+        ]
+
+        plugin_configs = []
+
+        for transpiled in files:
+            plugin = Plugin.objects.create(organization=self.team.organization, name="My Plugin", plugin_type="source")
+            PluginSourceFile.objects.create(
+                plugin=plugin,
+                filename="site.ts",
+                source="IGNORED FOR TESTING",
+                transpiled=transpiled,
+                status=PluginSourceFile.Status.TRANSPILED,
+            )
+            plugin_configs.append(
+                PluginConfig.objects.create(
+                    plugin=plugin,
+                    enabled=True,
+                    order=1,
+                    team=self.team,
+                    config={},
+                    web_token="tokentoken",
+                )
+            )
+
+        plugin_configs[2].enabled = False
+
+        js = self.remote_config.get_config_js_via_token(self.team.api_token)
+
+        # TODO: Come up with a good way of solidly testing this, ideally by running it in an actual browser environment
+        assert js == snapshot(
+            """\
+(function() {
+  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {};
+  window._POSTHOG_REMOTE_CONFIG['phc_12345'] = {
+    config: {"token": "phc_12345", "supportedCompression": ["gzip", "gzip-js"], "hasFeatureFlags": false, "captureDeadClicks": false, "capturePerformance": {"network_timing": true, "web_vitals": false, "web_vitals_allowed_metrics": null}, "autocapture_opt_out": false, "autocaptureExceptions": false, "analytics": {"endpoint": "/i/v0/e/"}, "elementsChainAsString": true, "sessionRecording": {"endpoint": "/s/", "consoleLogRecordingEnabled": true, "recorderVersion": "v2", "sampleRate": null, "minimumDurationMilliseconds": null, "linkedFlag": null, "networkPayloadCapture": null, "urlTriggers": [], "urlBlocklist": [], "eventTriggers": [], "scriptConfig": null}, "heatmaps": false, "surveys": [], "defaultIdentifiedOnly": true},
+    siteApps: [    
+    {
+      id: 'tokentoken',
+      init: function(config) {
+            (function () { return { inject: (data) => console.log('injected!', data)}; })().inject({ config:{}, posthog:config.posthog });
+        config.callback();
+      }
+    },    
+    {
+      id: 'tokentoken',
+      init: function(config) {
+            (function () { return { inject: (data) => console.log('injected 2!', data)}; })().inject({ config:{}, posthog:config.posthog });
+        config.callback();
+      }
+    },    
+    {
+      id: 'tokentoken',
+      init: function(config) {
+            (function () { return { inject: (data) => console.log('injected but disabled!', data)}; })().inject({ config:{}, posthog:config.posthog });
+        config.callback();
+      }
+    }]
+  }
+})();\
+"""  # noqa: W291, W293
+        )
+
+    def test_renders_js_including_site_functions(self):
+        non_site_app = HogFunction.objects.create(
+            name="Non site app",
+            type=HogFunctionType.DESTINATION,
+            team=self.team,
+            enabled=True,
+            filters={
+                "events": [{"id": "$pageview", "name": "$pageview", "type": "events", "order": 0}],
+                "filter_test_accounts": True,
+            },
+        )
+
+        site_destination = HogFunction.objects.create(
+            name="Site destination",
+            type=HogFunctionType.SITE_DESTINATION,
+            team=self.team,
+            enabled=True,
+            filters={
+                "events": [{"id": "$pageview", "name": "$pageview", "type": "events", "order": 0}],
+                "filter_test_accounts": True,
+            },
+        )
+
+        site_app = HogFunction.objects.create(
+            name="Site app",
+            type=HogFunctionType.SITE_APP,
+            team=self.team,
+            enabled=True,
+        )
+
+        js = self.remote_config.get_config_js_via_token(self.team.api_token)
+        assert str(non_site_app.id) not in js
+        assert str(site_destination.id) in js
+        assert str(site_app.id) in js
+
+        js = js.replace(str(non_site_app.id), "NON_SITE_APP_ID")
+        js = js.replace(str(site_destination.id), "SITE_DESTINATION_ID")
+        js = js.replace(str(site_app.id), "SITE_APP_ID")
+
+        # TODO: Come up with a good way of solidly testing this, ideally by running it in an actual browser environment
+        assert js == snapshot(
+            """\
+(function() {
+  window._POSTHOG_REMOTE_CONFIG = window._POSTHOG_REMOTE_CONFIG || {};
+  window._POSTHOG_REMOTE_CONFIG['phc_12345'] = {
+    config: {"token": "phc_12345", "supportedCompression": ["gzip", "gzip-js"], "hasFeatureFlags": false, "captureDeadClicks": false, "capturePerformance": {"network_timing": true, "web_vitals": false, "web_vitals_allowed_metrics": null}, "autocapture_opt_out": false, "autocaptureExceptions": false, "analytics": {"endpoint": "/i/v0/e/"}, "elementsChainAsString": true, "sessionRecording": {"endpoint": "/s/", "consoleLogRecordingEnabled": true, "recorderVersion": "v2", "sampleRate": null, "minimumDurationMilliseconds": null, "linkedFlag": null, "networkPayloadCapture": null, "urlTriggers": [], "urlBlocklist": [], "eventTriggers": [], "scriptConfig": null}, "heatmaps": false, "surveys": [], "defaultIdentifiedOnly": true},
+    siteApps: [    
+    {
+      id: 'SITE_DESTINATION_ID',
+      init: function(config) { return     (function() {
+        function toString (value) { return __STLToString(value) }
+        function match (str, pattern) { return !str || !pattern ? false : new RegExp(pattern).test(str) }
+        function ilike (str, pattern) { return __like(str, pattern, true) }
+        function __like(str, pattern, caseInsensitive = false) {
+            if (caseInsensitive) {
+                str = str.toLowerCase()
+                pattern = pattern.toLowerCase()
+            }
+            pattern = String(pattern)
+                .replaceAll(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')
+                .replaceAll('%', '.*')
+                .replaceAll('_', '.')
+            return new RegExp(pattern).test(str)
+        }
+        function __getProperty(objectOrArray, key, nullish) {
+            if ((nullish && !objectOrArray) || key === 0) { return null }
+            if (Array.isArray(objectOrArray)) { return key > 0 ? objectOrArray[key - 1] : objectOrArray[objectOrArray.length + key] }
+            else { return objectOrArray[key] }
+        }
+        function __STLToString(arg) {
+            if (arg && __isHogDate(arg)) { return `${arg.year}-${arg.month.toString().padStart(2, '0')}-${arg.day.toString().padStart(2, '0')}`; }
+            else if (arg && __isHogDateTime(arg)) { return __DateTimeToString(arg); }
+            return __printHogStringOutput(arg); }
+        function __printHogStringOutput(obj) { if (typeof obj === 'string') { return obj } return __printHogValue(obj) }
+        function __printHogValue(obj, marked = new Set()) {
+            if (typeof obj === 'object' && obj !== null && obj !== undefined) {
+                if (marked.has(obj) && !__isHogDateTime(obj) && !__isHogDate(obj) && !__isHogError(obj)) { return 'null'; }
+                marked.add(obj);
+                try {
+                    if (Array.isArray(obj)) {
+                        if (obj.__isHogTuple) { return obj.length < 2 ? `tuple(${obj.map((o) => __printHogValue(o, marked)).join(', ')})` : `(${obj.map((o) => __printHogValue(o, marked)).join(', ')})`; }
+                        return `[${obj.map((o) => __printHogValue(o, marked)).join(', ')}]`;
+                    }
+                    if (__isHogDateTime(obj)) { const millis = String(obj.dt); return `DateTime(${millis}${millis.includes('.') ? '' : '.0'}, ${__escapeString(obj.zone)})`; }
+                    if (__isHogDate(obj)) return `Date(${obj.year}, ${obj.month}, ${obj.day})`;
+                    if (__isHogError(obj)) { return `${String(obj.type)}(${__escapeString(obj.message)}${obj.payload ? `, ${__printHogValue(obj.payload, marked)}` : ''})`; }
+                    if (obj instanceof Map) { return `{${Array.from(obj.entries()).map(([key, value]) => `${__printHogValue(key, marked)}: ${__printHogValue(value, marked)}`).join(', ')}}`; }
+                    return `{${Object.entries(obj).map(([key, value]) => `${__printHogValue(key, marked)}: ${__printHogValue(value, marked)}`).join(', ')}}`;
+                } finally {
+                    marked.delete(obj);
+                }
+            } else if (typeof obj === 'boolean') return obj ? 'true' : 'false';
+            else if (obj === null || obj === undefined) return 'null';
+            else if (typeof obj === 'string') return __escapeString(obj);
+                    if (typeof obj === 'function') return `fn<${__escapeIdentifier(obj.name || 'lambda')}(${obj.length})>`;
+            return obj.toString();
+        }
+        function __isHogError(obj) {return obj && obj.__hogError__ === true}
+        function __escapeString(value) {
+            const singlequoteEscapeCharsMap = { '\\b': '\\\\b', '\\f': '\\\\f', '\\r': '\\\\r', '\\n': '\\\\n', '\\t': '\\\\t', '\\0': '\\\\0', '\\v': '\\\\v', '\\\\': '\\\\\\\\', "'": "\\\\'" }
+            return `'${value.split('').map((c) => singlequoteEscapeCharsMap[c] || c).join('')}'`;
+        }
+        function __escapeIdentifier(identifier) {
+            const backquoteEscapeCharsMap = { '\\b': '\\\\b', '\\f': '\\\\f', '\\r': '\\\\r', '\\n': '\\\\n', '\\t': '\\\\t', '\\0': '\\\\0', '\\v': '\\\\v', '\\\\': '\\\\\\\\', '`': '\\\\`' }
+            if (typeof identifier === 'number') return identifier.toString();
+            if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier)) return identifier;
+            return `\\`${identifier.split('').map((c) => backquoteEscapeCharsMap[c] || c).join('')}\\``;
+        }
+        function __isHogDateTime(obj) { return obj && obj.__hogDateTime__ === true }
+        function __isHogDate(obj) { return obj && obj.__hogDate__ === true }
+        function __DateTimeToString(dt) {
+            if (__isHogDateTime(dt)) {
+                const date = new Date(dt.dt * 1000);
+                const timeZone = dt.zone || 'UTC';
+                const milliseconds = Math.floor(dt.dt * 1000 % 1000);
+                const options = { timeZone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false };
+                const formatter = new Intl.DateTimeFormat('en-US', options);
+                const parts = formatter.formatToParts(date);
+                let year, month, day, hour, minute, second;
+                for (const part of parts) {
+                    switch (part.type) {
+                        case 'year': year = part.value; break;
+                        case 'month': month = part.value; break;
+                        case 'day': day = part.value; break;
+                        case 'hour': hour = part.value; break;
+                        case 'minute': minute = part.value; break;
+                        case 'second': second = part.value; break;
+                        default: break;
+                    }
+                }
+                const getOffset = (date, timeZone) => {
+                    const tzDate = new Date(date.toLocaleString('en-US', { timeZone }));
+                    const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }));
+                    const offset = (tzDate - utcDate) / 60000; // in minutes
+                    const sign = offset >= 0 ? '+' : '-';
+                    const absOffset = Math.abs(offset);
+                    const hours = Math.floor(absOffset / 60);
+                    const minutes = absOffset % 60;
+                    return `${sign}${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+                };
+                let offset = 'Z';
+                if (timeZone !== 'UTC') {
+                    offset = getOffset(date, timeZone);
+                }
+                let isoString = `${year}-${month}-${day}T${hour}:${minute}:${second}`;
+                isoString += `.${milliseconds.toString().padStart(3, '0')}`;
+                isoString += offset;
+                return isoString;
+            }
+        }
+        function buildInputs(globals, initial) {
+        let inputs = {
+        };
+        let __getGlobal = (key) => key === 'inputs' ? inputs : globals[key];
+        return inputs;}
+        const source = (function () {let exports={};"use strict";;return exports;})();
+            let processEvent = undefined;
+            if ('onEvent' in source) {
+                processEvent = function processEvent(globals, posthog) {
+                    if (!('onEvent' in source)) { return; };
+                    const inputs = buildInputs(globals);
+                    const filterGlobals = { ...globals.groups, ...globals.event, person: globals.person, inputs, pdi: { distinct_id: globals.event.distinct_id, person: globals.person } };
+                    let __getGlobal = (key) => filterGlobals[key];
+                    const filterMatches = !!(!!(!ilike(__getProperty(__getProperty(__getGlobal("person"), "properties", true), "email", true), "%@posthog.com%") && ((!match(toString(__getProperty(__getGlobal("properties"), "$host", true)), "^(localhost|127\\\\.0\\\\.0\\\\.1)($|:)")) ?? 1) && (__getGlobal("event") == "$pageview")));
+                    if (!filterMatches) { return; }
+                    ;
+                }
+            }
+        
+            function init(config) {
+                const posthog = config.posthog;
+                const callback = config.callback;
+                if ('onLoad' in source) {
+                    const globals = {
+                        person: {
+                            properties: posthog.get_property('$stored_person_properties'),
+                        }
+                    }
+                    const r = source.onLoad({ inputs: buildInputs(globals, true), posthog: posthog });
+                    if (r && typeof r.then === 'function' && typeof r.finally === 'function') { r.catch(() => callback(false)).then(() => callback(true)) } else { callback(true) }
+                } else {
+                    callback(true);
+                }
+        
+                return {
+                    processEvent: (globals) => processEvent(globals, posthog)
+                }
+            }
+        
+            return { init: init };
+        })().init(config) } 
+    },    
+    {
+      id: 'SITE_APP_ID',
+      init: function(config) { return     (function() {
+        
+        function buildInputs(globals, initial) {
+        let inputs = {
+        };
+        let __getGlobal = (key) => key === 'inputs' ? inputs : globals[key];
+        return inputs;}
+        const source = (function () {let exports={};"use strict";;return exports;})();
+            let processEvent = undefined;
+            if ('onEvent' in source) {
+                processEvent = function processEvent(globals, posthog) {
+                    if (!('onEvent' in source)) { return; };
+                    const inputs = buildInputs(globals);
+                    const filterGlobals = { ...globals.groups, ...globals.event, person: globals.person, inputs, pdi: { distinct_id: globals.event.distinct_id, person: globals.person } };
+                    let __getGlobal = (key) => filterGlobals[key];
+                    const filterMatches = true;
+                    if (!filterMatches) { return; }
+                    ;
+                }
+            }
+        
+            function init(config) {
+                const posthog = config.posthog;
+                const callback = config.callback;
+                if ('onLoad' in source) {
+                    const globals = {
+                        person: {
+                            properties: posthog.get_property('$stored_person_properties'),
+                        }
+                    }
+                    const r = source.onLoad({ inputs: buildInputs(globals, true), posthog: posthog });
+                    if (r && typeof r.then === 'function' && typeof r.finally === 'function') { r.catch(() => callback(false)).then(() => callback(true)) } else { callback(true) }
+                } else {
+                    callback(true);
+                }
+        
+                return {
+                    processEvent: (globals) => processEvent(globals, posthog)
+                }
+            }
+        
+            return { init: init };
+        })().init(config) } 
+    }]
+  }
+})();\
+"""  # noqa: W291, W293
+        )
diff --git a/posthog/plugins/site.py b/posthog/plugins/site.py
index af59c2b5dfef6..90bf3dc935b2d 100644
--- a/posthog/plugins/site.py
+++ b/posthog/plugins/site.py
@@ -22,6 +22,16 @@ class WebJsUrl:
     type: str
 
 
+def get_site_config_from_schema(config_schema: Optional[list[dict]], config: Optional[dict]):
+    if not config or not config_schema:
+        return {}
+    return {
+        schema_element["key"]: config.get(schema_element["key"], schema_element.get("default", None))
+        for schema_element in config_schema
+        if schema_element.get("site", False) and schema_element.get("key", False)
+    }
+
+
 def get_transpiled_site_source(id: int, token: str) -> Optional[WebJsSource]:
     from posthog.models import PluginConfig, PluginSourceFile
 
@@ -49,6 +59,34 @@ def get_transpiled_site_source(id: int, token: str) -> Optional[WebJsSource]:
     return WebJsSource(*(list(response)))
 
 
+def get_site_apps_for_team(team_id: int) -> list[WebJsSource]:
+    from posthog.models import PluginConfig, PluginSourceFile
+
+    rows = (
+        PluginConfig.objects.filter(
+            team_id=team_id,
+            enabled=True,
+            plugin__pluginsourcefile__filename="site.ts",
+            plugin__pluginsourcefile__status=PluginSourceFile.Status.TRANSPILED,
+        )
+        .values_list(
+            "id",
+            "plugin__pluginsourcefile__transpiled",
+            "web_token",
+            "plugin__config_schema",
+            "config",
+        )
+        .all()
+    )
+
+    items = []
+
+    for row in rows:
+        items.append(WebJsSource(*(list(row))))
+
+    return items
+
+
 def get_decide_site_apps(team: "Team", using_database: str = "default") -> list[dict]:
     from posthog.models import PluginConfig, PluginSourceFile
 
@@ -103,13 +141,3 @@ def site_function_url(source: tuple) -> str:
     return [
         asdict(WebJsUrl(source[0], site_function_url(source), source[2] or "site_destination")) for source in sources
     ]
-
-
-def get_site_config_from_schema(config_schema: Optional[list[dict]], config: Optional[dict]):
-    if not config or not config_schema:
-        return {}
-    return {
-        schema_element["key"]: config.get(schema_element["key"], schema_element.get("default", None))
-        for schema_element in config_schema
-        if schema_element.get("site", False) and schema_element.get("key", False)
-    }
diff --git a/posthog/queries/base.py b/posthog/queries/base.py
index 34713cad4a1d9..907b741eafc76 100644
--- a/posthog/queries/base.py
+++ b/posthog/queries/base.py
@@ -279,7 +279,7 @@ def lookup_q(key: str, value: Any) -> Q:
 
 
 def property_to_Q(
-    team_id: int,
+    project_id: int,
     property: Property,
     override_property_values: Optional[dict[str, Any]] = None,
     cohorts_cache: Optional[dict[int, CohortOrEmpty]] = None,
@@ -298,7 +298,7 @@ def property_to_Q(
             if cohorts_cache.get(cohort_id) is None:
                 queried_cohort = (
                     Cohort.objects.db_manager(using_database)
-                    .filter(pk=cohort_id, team_id=team_id, deleted=False)
+                    .filter(pk=cohort_id, team__project_id=project_id, deleted=False)
                     .first()
                 )
                 cohorts_cache[cohort_id] = queried_cohort or ""
@@ -306,7 +306,9 @@ def property_to_Q(
             cohort = cohorts_cache[cohort_id]
         else:
             cohort = (
-                Cohort.objects.db_manager(using_database).filter(pk=cohort_id, team_id=team_id, deleted=False).first()
+                Cohort.objects.db_manager(using_database)
+                .filter(pk=cohort_id, team__project_id=project_id, deleted=False)
+                .first()
             )
 
         if not cohort:
@@ -329,7 +331,7 @@ def property_to_Q(
             # :TRICKY: This has potential to create an infinite loop if the cohort is recursive.
             # But, this shouldn't happen because we check for cyclic cohorts on creation.
             return property_group_to_Q(
-                team_id,
+                project_id,
                 cohort.properties,
                 override_property_values,
                 cohorts_cache,
@@ -389,7 +391,7 @@ def property_to_Q(
 
 
 def property_group_to_Q(
-    team_id: int,
+    project_id: int,
     property_group: PropertyGroup,
     override_property_values: Optional[dict[str, Any]] = None,
     cohorts_cache: Optional[dict[int, CohortOrEmpty]] = None,
@@ -405,7 +407,7 @@ def property_group_to_Q(
     if isinstance(property_group.values[0], PropertyGroup):
         for group in property_group.values:
             group_filter = property_group_to_Q(
-                team_id,
+                project_id,
                 cast(PropertyGroup, group),
                 override_property_values,
                 cohorts_cache,
@@ -418,7 +420,9 @@ def property_group_to_Q(
     else:
         for property in property_group.values:
             property = cast(Property, property)
-            property_filter = property_to_Q(team_id, property, override_property_values, cohorts_cache, using_database)
+            property_filter = property_to_Q(
+                project_id, property, override_property_values, cohorts_cache, using_database
+            )
             if property_group.type == PropertyOperatorType.OR:
                 if property.negation:
                     filters |= ~property_filter
diff --git a/posthog/queries/breakdown_props.py b/posthog/queries/breakdown_props.py
index 18fa862b8333a..c4d82984f8e84 100644
--- a/posthog/queries/breakdown_props.py
+++ b/posthog/queries/breakdown_props.py
@@ -359,9 +359,9 @@ def _format_all_query(team: Team, filter: Filter, **kwargs) -> tuple[str, dict]:
 def format_breakdown_cohort_join_query(team: Team, filter: Filter, **kwargs) -> tuple[str, list, dict]:
     entity = kwargs.pop("entity", None)
     cohorts = (
-        Cohort.objects.filter(team_id=team.pk, pk__in=[b for b in filter.breakdown if b != "all"])
+        Cohort.objects.filter(team__project_id=team.project_id, pk__in=[b for b in filter.breakdown if b != "all"])
         if isinstance(filter.breakdown, list)
-        else Cohort.objects.filter(team_id=team.pk, pk=filter.breakdown)
+        else Cohort.objects.filter(team__project_id=team.project_id, pk=filter.breakdown)
     )
     cohort_queries, params = _parse_breakdown_cohorts(list(cohorts), filter.hogql_context)
     ids = [cohort.pk for cohort in cohorts]
diff --git a/posthog/queries/column_optimizer/foss_column_optimizer.py b/posthog/queries/column_optimizer/foss_column_optimizer.py
index 4fffbd1faa350..c998d92480b5a 100644
--- a/posthog/queries/column_optimizer/foss_column_optimizer.py
+++ b/posthog/queries/column_optimizer/foss_column_optimizer.py
@@ -3,7 +3,7 @@
 from typing import Union, cast
 from collections.abc import Generator
 
-from posthog.clickhouse.materialized_columns import ColumnName, get_enabled_materialized_columns
+from posthog.clickhouse.materialized_columns import ColumnName, get_materialized_column_for_property
 from posthog.constants import TREND_FILTER_TYPE_ACTIONS, FunnelCorrelationType
 from posthog.models.action.util import (
     get_action_tables_and_properties,
@@ -72,12 +72,14 @@ def columns_to_query(
         table_column: str = "properties",
     ) -> set[ColumnName]:
         "Transforms a list of property names to what columns are needed for that query"
-
-        materialized_columns = get_enabled_materialized_columns(table)
-        return {
-            materialized_columns.get((property_name, table_column), table_column)
-            for property_name, _, _ in used_properties
-        }
+        column_names = set()
+        for property_name, _, _ in used_properties:
+            column = get_materialized_column_for_property(table, table_column, property_name)
+            if column is not None and not column.is_nullable:
+                column_names.add(column.name)
+            else:
+                column_names.add(table_column)
+        return column_names
 
     @cached_property
     def is_using_person_properties(self) -> bool:
diff --git a/posthog/queries/event_query/event_query.py b/posthog/queries/event_query/event_query.py
index 5458929aa5ae6..7bab914cd0cda 100644
--- a/posthog/queries/event_query/event_query.py
+++ b/posthog/queries/event_query/event_query.py
@@ -10,7 +10,6 @@
 from posthog.models.filters.path_filter import PathFilter
 from posthog.models.filters.properties_timeline_filter import PropertiesTimelineFilter
 from posthog.models.filters.retention_filter import RetentionFilter
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
 from posthog.models.filters.stickiness_filter import StickinessFilter
 from posthog.models.property import PropertyGroup, PropertyName
 from posthog.models.property.util import parse_prop_grouped_clauses
@@ -52,7 +51,6 @@ def __init__(
             PathFilter,
             RetentionFilter,
             StickinessFilter,
-            SessionRecordingsFilter,
             PropertiesTimelineFilter,
         ],
         team: Team,
@@ -191,7 +189,7 @@ def _determine_should_join_sessions(self) -> None:
 
     def _does_cohort_need_persons(self, prop: Property) -> bool:
         try:
-            cohort: Cohort = Cohort.objects.get(pk=prop.value, team_id=self._team_id)
+            cohort: Cohort = Cohort.objects.get(pk=prop.value)
         except Cohort.DoesNotExist:
             return False
         if is_precalculated_query(cohort):
diff --git a/posthog/queries/foss_cohort_query.py b/posthog/queries/foss_cohort_query.py
index a7e020158872e..f11e53abb528d 100644
--- a/posthog/queries/foss_cohort_query.py
+++ b/posthog/queries/foss_cohort_query.py
@@ -179,7 +179,10 @@ def __init__(
 
     @staticmethod
     def unwrap_cohort(filter: Filter, team_id: int) -> Filter:
+        team: Optional[Team] = None
+
         def _unwrap(property_group: PropertyGroup, negate_group: bool = False) -> PropertyGroup:
+            nonlocal team
             if len(property_group.values):
                 if isinstance(property_group.values[0], PropertyGroup):
                     # dealing with a list of property groups, so unwrap each one
@@ -211,7 +214,11 @@ def _unwrap(property_group: PropertyGroup, negate_group: bool = False) -> Proper
                         negation_value = not current_negation if negate_group else current_negation
                         if prop.type in ["cohort", "precalculated-cohort"]:
                             try:
-                                prop_cohort: Cohort = Cohort.objects.get(pk=prop.value, team_id=team_id)
+                                if team is None:  # This ensures we only fetch team if needed, but never more than once
+                                    team = Team.objects.get(pk=team_id)
+                                prop_cohort: Cohort = Cohort.objects.get(
+                                    pk=prop.value, team__project_id=team.project_id
+                                )
                                 if prop_cohort.is_static:
                                     new_property_group_list.append(
                                         PropertyGroup(
diff --git a/posthog/queries/person_query.py b/posthog/queries/person_query.py
index b9abde6524f76..69db14fb1bbb6 100644
--- a/posthog/queries/person_query.py
+++ b/posthog/queries/person_query.py
@@ -261,7 +261,7 @@ def _get_multiple_cohorts_clause(self, prepend: str = "") -> tuple[str, dict]:
             # TODO: doesn't support non-caclculated cohorts
             for index, property in enumerate(self._cohort_filters):
                 try:
-                    cohort = Cohort.objects.get(pk=property.value, team_id=self._team_id)
+                    cohort = Cohort.objects.get(pk=property.value)
                     if property.type == "static-cohort":
                         subquery, subquery_params = format_static_cohort_query(cohort, index, prepend)
                     else:
diff --git a/posthog/queries/stickiness/stickiness.py b/posthog/queries/stickiness/stickiness.py
index 26204b8e9964f..5e316afae3957 100644
--- a/posthog/queries/stickiness/stickiness.py
+++ b/posthog/queries/stickiness/stickiness.py
@@ -23,7 +23,7 @@ def run(self, filter: StickinessFilter, team: Team, *args, **kwargs) -> list[dic
         response = []
         for entity in filter.entities:
             if entity.type == TREND_FILTER_TYPE_ACTIONS and entity.id is not None:
-                entity.name = Action.objects.only("name").get(team=team, pk=entity.id).name
+                entity.name = Action.objects.only("name").get(team__project_id=team.project_id, pk=entity.id).name
 
             entity_resp = handle_compare(filter=filter, func=self._serialize_entity, team=team, entity=entity)
             response.extend(entity_resp)
diff --git a/posthog/queries/test/__snapshots__/test_trends.ambr b/posthog/queries/test/__snapshots__/test_trends.ambr
index 9e2cc7eda3a1a..63cc1b57cf4e8 100644
--- a/posthog/queries/test/__snapshots__/test_trends.ambr
+++ b/posthog/queries/test/__snapshots__/test_trends.ambr
@@ -22,11 +22,14 @@
 # name: TestTrends.test_action_filtering_with_cohort.2
   '''
   /* celery:posthog.tasks.calculate_cohort.clear_stale_cohort */
-  SELECT count()
+  SELECT team_id,
+         count() AS stale_people_count
   FROM cohortpeople
-  WHERE team_id = 99999
+  WHERE team_id IN [1, 2, 3, 4, 5 /* ... */]
     AND cohort_id = 99999
     AND version < 2
+  GROUP BY team_id
+  HAVING stale_people_count > 0
   '''
 # ---
 # name: TestTrends.test_action_filtering_with_cohort.3
@@ -110,11 +113,14 @@
 # name: TestTrends.test_action_filtering_with_cohort_poe_v2.2
   '''
   /* celery:posthog.tasks.calculate_cohort.clear_stale_cohort */
-  SELECT count()
+  SELECT team_id,
+         count() AS stale_people_count
   FROM cohortpeople
-  WHERE team_id = 99999
+  WHERE team_id IN [1, 2, 3, 4, 5 /* ... */]
     AND cohort_id = 99999
     AND version < 2
+  GROUP BY team_id
+  HAVING stale_people_count > 0
   '''
 # ---
 # name: TestTrends.test_action_filtering_with_cohort_poe_v2.3
@@ -853,26 +859,70 @@
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', '') AS value,
+         count(*) as count
+  FROM events e SAMPLE 1.0
+  WHERE team_id = 99999
+    AND ((event = 'sign up'))
+    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2019-12-28 00:00:00', 'UTC')
+    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+  GROUP BY value
+  ORDER BY count DESC, value DESC
+  LIMIT 26
+  OFFSET 0
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.1
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(8)
+              UNION ALL SELECT toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['other_value', '$$_posthog_breakdown_null_$$', 'value'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT pdi.person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['other_value', '$$_posthog_breakdown_null_$$', 'value']), (['other_value', '$$_posthog_breakdown_null_$$', 'value']), '$$_posthog_breakdown_other_$$') as breakdown_value
+           FROM events e SAMPLE 1.0
+           INNER JOIN
+             (SELECT distinct_id,
+                     argMax(person_id, version) as person_id
+              FROM person_distinct_id2
+              WHERE team_id = 99999
+              GROUP BY distinct_id
+              HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+           WHERE e.team_id = 99999
+             AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+             AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+             AND ((event = 'sign up'))
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.10
@@ -1037,38 +1087,122 @@
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.2
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', '') AS value,
+         count(*) as count
+  FROM events e SAMPLE 1.0
+  WHERE team_id = 99999
+    AND event = 'sign up'
+    AND toTimeZone(timestamp, 'UTC') >= toDateTime('2019-12-28 00:00:00', 'UTC')
+    AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+  GROUP BY value
+  ORDER BY count DESC, value DESC
+  LIMIT 26
+  OFFSET 0
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.3
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(8)
+              UNION ALL SELECT toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['other_value', '$$_posthog_breakdown_null_$$', 'value'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT pdi.person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['other_value', '$$_posthog_breakdown_null_$$', 'value']), (['other_value', '$$_posthog_breakdown_null_$$', 'value']), '$$_posthog_breakdown_other_$$') as breakdown_value
+           FROM events e SAMPLE 1.0
+           INNER JOIN
+             (SELECT distinct_id,
+                     argMax(person_id, version) as person_id
+              FROM person_distinct_id2
+              WHERE team_id = 99999
+              GROUP BY distinct_id
+              HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+           WHERE e.team_id = 99999
+             AND event = 'sign up'
+             AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+             AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.4
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(8)
+              UNION ALL SELECT toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['other_value', '$$_posthog_breakdown_null_$$', 'value'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT pdi.person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['other_value', '$$_posthog_breakdown_null_$$', 'value']), (['other_value', '$$_posthog_breakdown_null_$$', 'value']), '$$_posthog_breakdown_other_$$') as breakdown_value
+           FROM events e SAMPLE 1.0
+           INNER JOIN
+             (SELECT distinct_id,
+                     argMax(person_id, version) as person_id
+              FROM person_distinct_id2
+              WHERE team_id = 99999
+              GROUP BY distinct_id
+              HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+           WHERE e.team_id = 99999
+             AND event = 'sign up'
+             AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+             AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
   '''
 # ---
 # name: TestTrends.test_dau_with_breakdown_filtering_with_sampling.5
@@ -1624,18 +1758,6 @@
 # ---
 # name: TestTrends.test_person_filtering_in_cohort_in_action
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action.1
-  '''
   
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', '') AS value,
          count(*) as count
@@ -1669,7 +1791,7 @@
   OFFSET 0
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action.2
+# name: TestTrends.test_person_filtering_in_cohort_in_action.1
   '''
   
   SELECT groupArray(day_start) as date,
@@ -1733,19 +1855,71 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2
+# name: TestTrends.test_person_filtering_in_cohort_in_action.2
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(8)
+              UNION ALL SELECT toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['$$_posthog_breakdown_null_$$', 'value', 'other_value'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(*) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), '$$_posthog_breakdown_other_$$') as breakdown_value
+           FROM events e
+           INNER JOIN
+             (SELECT distinct_id,
+                     argMax(person_id, version) as person_id
+              FROM person_distinct_id2
+              WHERE team_id = 99999
+              GROUP BY distinct_id
+              HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+           WHERE e.team_id = 99999
+             AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+             AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+             AND ((event = 'sign up'
+                   AND (pdi.person_id IN
+                          (SELECT id
+                           FROM person
+                           WHERE team_id = 99999
+                             AND id IN
+                               (SELECT id
+                                FROM person
+                                WHERE team_id = 99999
+                                  AND ((has(['some_val'], replaceRegexpAll(JSONExtractRaw(properties, '$some_prop'), '^"|"$', '')))) )
+                           GROUP BY id
+                           HAVING max(is_deleted) = 0
+                           AND ((has(['some_val'], replaceRegexpAll(JSONExtractRaw(argMax(person.properties, version), '$some_prop'), '^"|"$', '')))) SETTINGS optimize_aggregation_in_order = 1))))
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
   '''
 # ---
-# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.1
+# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2
   '''
   
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', '') AS value,
@@ -1781,6 +1955,72 @@
   OFFSET 0
   '''
 # ---
+# name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.1
+  '''
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(8)
+              UNION ALL SELECT toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['$$_posthog_breakdown_null_$$', 'value', 'other_value'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(*) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), '$$_posthog_breakdown_other_$$') as breakdown_value
+           FROM events e
+           LEFT OUTER JOIN
+             (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                     person_distinct_id_overrides.distinct_id AS distinct_id
+              FROM person_distinct_id_overrides
+              WHERE equals(person_distinct_id_overrides.team_id, 99999)
+              GROUP BY person_distinct_id_overrides.distinct_id
+              HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0)) AS overrides ON e.distinct_id = overrides.distinct_id
+           WHERE e.team_id = 99999
+             AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+             AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+             AND notEmpty(e.person_id)
+             AND ((event = 'sign up'
+                   AND (if(notEmpty(overrides.distinct_id), overrides.person_id, e.person_id) IN
+                          (SELECT id
+                           FROM person
+                           WHERE team_id = 99999
+                             AND id IN
+                               (SELECT id
+                                FROM person
+                                WHERE team_id = 99999
+                                  AND ((has(['some_val'], replaceRegexpAll(JSONExtractRaw(properties, '$some_prop'), '^"|"$', '')))) )
+                           GROUP BY id
+                           HAVING max(is_deleted) = 0
+                           AND ((has(['some_val'], replaceRegexpAll(JSONExtractRaw(argMax(person.properties, version), '$some_prop'), '^"|"$', '')))) SETTINGS optimize_aggregation_in_order = 1))))
+             AND notEmpty(e.person_id)
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
+  '''
+# ---
 # name: TestTrends.test_person_filtering_in_cohort_in_action_poe_v2.2
   '''
   
@@ -4138,14 +4378,28 @@
 # ---
 # name: TestTrends.test_trends_any_event_total_count
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total
+  FROM
+    (SELECT SUM(total) AS count,
+            day_start
+     FROM
+       (SELECT toUInt16(0) AS total,
+               toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) AS day_start
+        FROM numbers(dateDiff('day', toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), toDateTime('2020-01-04 23:59:59', 'UTC')))
+        UNION ALL SELECT toUInt16(0) AS total,
+                         toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC'))
+        UNION ALL SELECT count(*) AS total,
+                         toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) AS date
+        FROM events e
+        WHERE team_id = 99999
+          AND 1 = 1
+          AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+          AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+        GROUP BY date)
+     GROUP BY day_start
+     ORDER BY day_start)
   '''
 # ---
 # name: TestTrends.test_trends_any_event_total_count.1
@@ -4166,7 +4420,7 @@
                          toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) AS date
         FROM events e
         WHERE team_id = 99999
-          AND 1 = 1
+          AND event = 'sign up'
           AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
           AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
         GROUP BY date)
@@ -4202,18 +4456,6 @@
 # ---
 # name: TestTrends.test_trends_breakdown_cumulative
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: TestTrends.test_trends_breakdown_cumulative.1
-  '''
   
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', '') AS value,
          count(*) as count
@@ -4228,7 +4470,7 @@
   OFFSET 0
   '''
 # ---
-# name: TestTrends.test_trends_breakdown_cumulative.2
+# name: TestTrends.test_trends_breakdown_cumulative.1
   '''
   
   SELECT groupArray(day_start) as date,
@@ -4288,19 +4530,67 @@
   ORDER BY breakdown_value
   '''
 # ---
-# name: TestTrends.test_trends_breakdown_cumulative_poe_v2
+# name: TestTrends.test_trends_breakdown_cumulative.2
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(8)
+              UNION ALL SELECT toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['$$_posthog_breakdown_null_$$', 'value', 'other_value'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            breakdown_value
+           FROM
+             (SELECT person_id,
+                     min(timestamp) as timestamp,
+                     breakdown_value
+              FROM
+                (SELECT pdi.person_id as person_id, timestamp, transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), '$$_posthog_breakdown_other_$$') as breakdown_value
+                 FROM events e
+                 INNER JOIN
+                   (SELECT distinct_id,
+                           argMax(person_id, version) as person_id
+                    FROM person_distinct_id2
+                    WHERE team_id = 99999
+                    GROUP BY distinct_id
+                    HAVING argMax(is_deleted, version) = 0) as pdi ON events.distinct_id = pdi.distinct_id
+                 WHERE e.team_id = 99999
+                   AND event = 'sign up'
+                   AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+                   AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC') )
+              GROUP BY person_id,
+                       breakdown_value) AS pdi
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
   '''
 # ---
-# name: TestTrends.test_trends_breakdown_cumulative_poe_v2.1
+# name: TestTrends.test_trends_breakdown_cumulative_poe_v2
   '''
   
   SELECT replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', '') AS value,
@@ -4324,6 +4614,68 @@
   OFFSET 0
   '''
 # ---
+# name: TestTrends.test_trends_breakdown_cumulative_poe_v2.1
+  '''
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total,
+         breakdown_value
+  FROM
+    (SELECT SUM(total) as count,
+            day_start,
+            breakdown_value
+     FROM
+       (SELECT *
+        FROM
+          (SELECT toUInt16(0) AS total,
+                  ticks.day_start as day_start,
+                  breakdown_value
+           FROM
+             (SELECT toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) as day_start
+              FROM numbers(8)
+              UNION ALL SELECT toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')) as day_start) as ticks
+           CROSS JOIN
+             (SELECT breakdown_value
+              FROM
+                (SELECT ['$$_posthog_breakdown_null_$$', 'value', 'other_value'] as breakdown_value) ARRAY
+              JOIN breakdown_value) as sec
+           ORDER BY breakdown_value,
+                    day_start
+           UNION ALL SELECT count(DISTINCT person_id) as total,
+                            toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) as day_start,
+                            breakdown_value
+           FROM
+             (SELECT person_id,
+                     min(timestamp) as timestamp,
+                     breakdown_value
+              FROM
+                (SELECT if(notEmpty(overrides.distinct_id), overrides.person_id, e.person_id) as person_id, timestamp, transform(ifNull(nullIf(replaceRegexpAll(JSONExtractRaw(properties, '$some_property'), '^"|"$', ''), ''), '$$_posthog_breakdown_null_$$'), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), (['$$_posthog_breakdown_null_$$', 'value', 'other_value']), '$$_posthog_breakdown_other_$$') as breakdown_value
+                 FROM events e
+                 LEFT OUTER JOIN
+                   (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id,
+                           person_distinct_id_overrides.distinct_id AS distinct_id
+                    FROM person_distinct_id_overrides
+                    WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                    GROUP BY person_distinct_id_overrides.distinct_id
+                    HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0)) AS overrides ON e.distinct_id = overrides.distinct_id
+                 WHERE e.team_id = 99999
+                   AND event = 'sign up'
+                   AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+                   AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+                   AND notEmpty(e.person_id)
+                   AND notEmpty(e.person_id) )
+              GROUP BY person_id,
+                       breakdown_value) AS pdi
+           GROUP BY day_start,
+                    breakdown_value))
+     GROUP BY day_start,
+              breakdown_value
+     ORDER BY breakdown_value,
+              day_start)
+  GROUP BY breakdown_value
+  ORDER BY breakdown_value
+  '''
+# ---
 # name: TestTrends.test_trends_breakdown_cumulative_poe_v2.2
   '''
   
@@ -4502,18 +4854,6 @@
 # ---
 # name: TestTrends.test_trends_compare_day_interval_relative_range
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
-  '''
-# ---
-# name: TestTrends.test_trends_compare_day_interval_relative_range.1
-  '''
   
   SELECT groupArray(day_start) as date,
          groupArray(count) AS total
@@ -4538,7 +4878,7 @@
      ORDER BY day_start)
   '''
 # ---
-# name: TestTrends.test_trends_compare_day_interval_relative_range.2
+# name: TestTrends.test_trends_compare_day_interval_relative_range.1
   '''
   
   SELECT groupArray(day_start) as date,
@@ -4564,6 +4904,32 @@
      ORDER BY day_start)
   '''
 # ---
+# name: TestTrends.test_trends_compare_day_interval_relative_range.2
+  '''
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total
+  FROM
+    (SELECT SUM(total) AS count,
+            day_start
+     FROM
+       (SELECT toUInt16(0) AS total,
+               toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) AS day_start
+        FROM numbers(dateDiff('day', toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), toDateTime('2020-01-04 23:59:59', 'UTC')))
+        UNION ALL SELECT toUInt16(0) AS total,
+                         toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC'))
+        UNION ALL SELECT count(*) AS total,
+                         toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) AS date
+        FROM events e
+        WHERE team_id = 99999
+          AND event = 'sign up'
+          AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+          AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+        GROUP BY date)
+     GROUP BY day_start
+     ORDER BY day_start)
+  '''
+# ---
 # name: TestTrends.test_trends_compare_day_interval_relative_range.3
   '''
   
@@ -4873,14 +5239,28 @@
 # ---
 # name: TestTrends.test_trends_per_day_cumulative
   '''
-  /* celery:posthog.tasks.tasks.sync_insight_caching_state */
-  SELECT team_id,
-         date_diff('second', max(timestamp), now()) AS age
-  FROM events
-  WHERE timestamp > date_sub(DAY, 3, now())
-    AND timestamp < now()
-  GROUP BY team_id
-  ORDER BY age;
+  
+  SELECT groupArray(day_start) as date,
+         groupArray(count) AS total
+  FROM
+    (SELECT SUM(total) AS count,
+            day_start
+     FROM
+       (SELECT toUInt16(0) AS total,
+               toStartOfDay(toDateTime('2020-01-04 23:59:59', 'UTC')) - toIntervalDay(number) AS day_start
+        FROM numbers(dateDiff('day', toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), toDateTime('2020-01-04 23:59:59', 'UTC')))
+        UNION ALL SELECT toUInt16(0) AS total,
+                         toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC'))
+        UNION ALL SELECT count(*) AS total,
+                         toStartOfDay(toTimeZone(toDateTime(timestamp, 'UTC'), 'UTC')) AS date
+        FROM events e
+        WHERE team_id = 99999
+          AND event = 'sign up'
+          AND toTimeZone(timestamp, 'UTC') >= toDateTime(toStartOfDay(toDateTime('2019-12-28 00:00:00', 'UTC')), 'UTC')
+          AND toTimeZone(timestamp, 'UTC') <= toDateTime('2020-01-04 23:59:59', 'UTC')
+        GROUP BY date)
+     GROUP BY day_start
+     ORDER BY day_start)
   '''
 # ---
 # name: TestTrends.test_trends_per_day_cumulative.1
diff --git a/posthog/queries/trends/trends.py b/posthog/queries/trends/trends.py
index 175813696e8a1..0f0cf911f0865 100644
--- a/posthog/queries/trends/trends.py
+++ b/posthog/queries/trends/trends.py
@@ -249,9 +249,11 @@ def _run_parallel(self, filter: Filter, team: Team) -> list[dict[str, Any]]:
 
     def run(self, filter: Filter, team: Team, is_csv_export: bool = False, *args, **kwargs) -> list[dict[str, Any]]:
         self.is_csv_export = is_csv_export
-        actions = Action.objects.filter(team_id=team.pk).order_by("-id")
+        actions = Action.objects.filter(team__project_id=team.project_id).order_by("-id")
         if len(filter.actions) > 0:
-            actions = Action.objects.filter(pk__in=[entity.id for entity in filter.actions], team_id=team.pk)
+            actions = Action.objects.filter(
+                pk__in=[entity.id for entity in filter.actions], team__project_id=team.project_id
+            )
 
         if filter.formula:
             return handle_compare(filter, self._run_formula_query, team)
diff --git a/posthog/queries/trends/trends_actors.py b/posthog/queries/trends/trends_actors.py
index f69db981d309a..c04c7378f8057 100644
--- a/posthog/queries/trends/trends_actors.py
+++ b/posthog/queries/trends/trends_actors.py
@@ -39,7 +39,7 @@ def aggregation_group_type_index(self):
 
     def actor_query(self, limit_actors: Optional[bool] = True) -> tuple[str, dict]:
         if self._filter.breakdown_type == "cohort" and self._filter.breakdown_value != "all":
-            cohort = Cohort.objects.get(pk=self._filter.breakdown_value, team_id=self._team.pk)
+            cohort = Cohort.objects.get(pk=self._filter.breakdown_value, team__project_id=self._team.project_id)
             self._filter = self._filter.shallow_clone(
                 {
                     "properties": self._filter.property_groups.combine_properties(
diff --git a/posthog/rbac/test/test_user_access_control.py b/posthog/rbac/test/test_user_access_control.py
index d398f246589a5..d17de05dd7b44 100644
--- a/posthog/rbac/test/test_user_access_control.py
+++ b/posthog/rbac/test/test_user_access_control.py
@@ -281,7 +281,9 @@ def test_filters_project_queryset_based_on_acs_always_allows_org_admin(self):
         filtered_teams = list(
             self.user_access_control.filter_queryset_by_access_level(Team.objects.all(), include_all_if_admin=True)
         )
-        assert filtered_teams == [self.team, team2, team3]
+        assert sorted(filtered_teams, key=lambda team: team.id) == sorted(
+            [self.team, team2, team3], key=lambda team: team.id
+        )
 
     def test_organization_access_control(self):
         # A team isn't always available like for organization level routing
diff --git a/posthog/schema.py b/posthog/schema.py
index a60f6ae8ac5ab..003c22eac087b 100644
--- a/posthog/schema.py
+++ b/posthog/schema.py
@@ -82,23 +82,6 @@ class AssistantBreakdownFilter(BaseModel):
     breakdown_limit: Optional[int] = Field(default=25, description="How many distinct values to show.")
 
 
-class AssistantCompareFilter(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-    )
-    compare: Optional[bool] = Field(
-        default=False, description="Whether to compare the current date range to a previous date range."
-    )
-    compare_to: Optional[str] = Field(
-        default="-7d",
-        description=(
-            "The date range to compare to. The value is a relative date. Examples of relative dates are: `-1y` for 1"
-            " year ago, `-14m` for 14 months ago, `-100w` for 100 weeks ago, `-14d` for 14 days ago, `-30h` for 30"
-            " hours ago."
-        ),
-    )
-
-
 class AssistantDateTimePropertyFilterOperator(StrEnum):
     IS_DATE_EXACT = "is_date_exact"
     IS_DATE_BEFORE = "is_date_before"
@@ -115,6 +98,7 @@ class AssistantEventMultipleBreakdownFilterType(StrEnum):
 class AssistantEventType(StrEnum):
     STATUS = "status"
     MESSAGE = "message"
+    CONVERSATION = "conversation"
 
 
 class AssistantFunnelsBreakdownType(StrEnum):
@@ -221,40 +205,12 @@ class AssistantGroupPropertyFilter3(BaseModel):
     value: str = Field(..., description="Value must be a date in ISO 8601 format.")
 
 
-class AssistantInsightDateRange(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-    )
-    date_from: Optional[str] = Field(
-        default="-7d",
-        description=(
-            "Start date. The value can be:\n- a relative date. Examples of relative dates are: `-1y` for 1 year ago,"
-            " `-14m` for 14 months ago, `-1w` for 1 week ago, `-14d` for 14 days ago, `-30h` for 30 hours ago.\n- an"
-            " absolute ISO 8601 date string. a constant `yStart` for the current year start. a constant `mStart` for"
-            " the current month start. a constant `dStart` for the current day start. Prefer using relative dates."
-        ),
-    )
-    date_to: Optional[str] = Field(
-        default=None,
-        description=(
-            "Right boundary of the date range. Use `null` for the current date. You can not use relative dates here."
-        ),
-    )
-
-
 class AssistantMessage(BaseModel):
     model_config = ConfigDict(
         extra="forbid",
     )
     content: str
-    done: Optional[bool] = Field(
-        default=None,
-        description=(
-            'We only need this "done" value to tell when the particular message is finished during its streaming. It'
-            " won't be necessary when we optimize streaming to NOT send the entire message every time a character is"
-            " added."
-        ),
-    )
+    id: Optional[str] = None
     type: Literal["ai"] = "ai"
 
 
@@ -413,6 +369,13 @@ class AutocompleteCompletionItemKind(StrEnum):
     SNIPPET = "Snippet"
 
 
+class BaseAssistantMessage(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    id: Optional[str] = None
+
+
 class BaseMathType(StrEnum):
     TOTAL = "total"
     DAU = "dau"
@@ -420,6 +383,7 @@ class BaseMathType(StrEnum):
     MONTHLY_ACTIVE = "monthly_active"
     UNIQUE_SESSION = "unique_session"
     FIRST_TIME_FOR_USER = "first_time_for_user"
+    FIRST_MATCHING_EVENT_FOR_USER = "first_matching_event_for_user"
 
 
 class BreakdownAttributionType(StrEnum):
@@ -538,8 +502,17 @@ class CompareFilter(BaseModel):
     model_config = ConfigDict(
         extra="forbid",
     )
-    compare: Optional[bool] = None
-    compare_to: Optional[str] = None
+    compare: Optional[bool] = Field(
+        default=False, description="Whether to compare the current date range to a previous date range."
+    )
+    compare_to: Optional[str] = Field(
+        default=None,
+        description=(
+            "The date range to compare to. The value is a relative date. Examples of relative dates are: `-1y` for 1"
+            " year ago, `-14m` for 14 months ago, `-100w` for 100 weeks ago, `-14d` for 14 days ago, `-30h` for 30"
+            " hours ago."
+        ),
+    )
 
 
 class ColorMode(StrEnum):
@@ -879,7 +852,7 @@ class FailureMessage(BaseModel):
         extra="forbid",
     )
     content: Optional[str] = None
-    done: Literal[True] = True
+    id: Optional[str] = None
     type: Literal["ai/failure"] = "ai/failure"
 
 
@@ -1077,7 +1050,7 @@ class HumanMessage(BaseModel):
         extra="forbid",
     )
     content: str
-    done: Literal[True] = Field(default=True, description="Human messages are only appended when done.")
+    id: Optional[str] = None
     type: Literal["human"] = "human"
 
 
@@ -1094,21 +1067,6 @@ class DayItem(BaseModel):
     value: Union[str, AwareDatetime, int]
 
 
-class InsightDateRange(BaseModel):
-    model_config = ConfigDict(
-        extra="forbid",
-    )
-    date_from: Optional[str] = "-7d"
-    date_to: Optional[str] = None
-    explicitDate: Optional[bool] = Field(
-        default=False,
-        description=(
-            "Whether the date_from and date_to should be used verbatim. Disables rounding to the start and end of"
-            " period."
-        ),
-    )
-
-
 class InsightFilterProperty(StrEnum):
     TRENDS_FILTER = "trendsFilter"
     FUNNELS_FILTER = "funnelsFilter"
@@ -1353,6 +1311,7 @@ class QueryResponseAlternative7(BaseModel):
     isValidView: Optional[bool] = None
     notices: list[HogQLNotice]
     query: Optional[str] = None
+    table_names: Optional[list[str]] = None
     warnings: list[HogQLNotice]
 
 
@@ -1420,7 +1379,7 @@ class ReasoningMessage(BaseModel):
         extra="forbid",
     )
     content: str
-    done: Literal[True] = True
+    id: Optional[str] = None
     substeps: Optional[list[str]] = None
     type: Literal["ai/reasoning"] = "ai/reasoning"
 
@@ -1483,7 +1442,7 @@ class RouterMessage(BaseModel):
         extra="forbid",
     )
     content: str
-    done: Literal[True] = Field(default=True, description="Router messages are not streamed, so they can only be done.")
+    id: Optional[str] = None
     type: Literal["ai/router"] = "ai/router"
 
 
@@ -2285,6 +2244,7 @@ class HogQLMetadataResponse(BaseModel):
     isValidView: Optional[bool] = None
     notices: list[HogQLNotice]
     query: Optional[str] = None
+    table_names: Optional[list[str]] = None
     warnings: list[HogQLNotice]
 
 
@@ -3574,7 +3534,7 @@ class AssistantFunnelsQuery(BaseModel):
     breakdownFilter: Optional[AssistantFunnelsBreakdownFilter] = Field(
         default=None, description="Breakdown the chart by a property"
     )
-    dateRange: Optional[AssistantInsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -3613,7 +3573,7 @@ class AssistantInsightsQueryBase(BaseModel):
     model_config = ConfigDict(
         extra="forbid",
     )
-    dateRange: Optional[AssistantInsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -3691,7 +3651,7 @@ class AssistantTrendsQuery(BaseModel):
         default=None, description="Breakdown of the events"
     )
     compareFilter: Optional[CompareFilter] = Field(default=None, description="Compare to date range")
-    dateRange: Optional[AssistantInsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -5386,7 +5346,8 @@ class VisualizationMessage(BaseModel):
         extra="forbid",
     )
     answer: Optional[Union[AssistantTrendsQuery, AssistantFunnelsQuery]] = None
-    done: Optional[bool] = None
+    id: Optional[str] = None
+    initiator: Optional[str] = None
     plan: Optional[str] = None
     type: Literal["ai/viz"] = "ai/viz"
 
@@ -5395,6 +5356,7 @@ class WebExternalClicksTableQuery(BaseModel):
     model_config = ConfigDict(
         extra="forbid",
     )
+    compareFilter: Optional[CompareFilter] = None
     conversionGoal: Optional[Union[ActionConversionGoal, CustomEventConversionGoal]] = None
     dateRange: Optional[DateRange] = None
     filterTestAccounts: Optional[bool] = None
@@ -5414,6 +5376,7 @@ class WebGoalsQuery(BaseModel):
     model_config = ConfigDict(
         extra="forbid",
     )
+    compareFilter: Optional[CompareFilter] = None
     conversionGoal: Optional[Union[ActionConversionGoal, CustomEventConversionGoal]] = None
     dateRange: Optional[DateRange] = None
     filterTestAccounts: Optional[bool] = None
@@ -5432,7 +5395,7 @@ class WebOverviewQuery(BaseModel):
     model_config = ConfigDict(
         extra="forbid",
     )
-    compare: Optional[bool] = None
+    compareFilter: Optional[CompareFilter] = None
     conversionGoal: Optional[Union[ActionConversionGoal, CustomEventConversionGoal]] = None
     dateRange: Optional[DateRange] = None
     filterTestAccounts: Optional[bool] = None
@@ -5452,6 +5415,7 @@ class WebStatsTableQuery(BaseModel):
         extra="forbid",
     )
     breakdownBy: WebStatsBreakdown
+    compareFilter: Optional[CompareFilter] = None
     conversionGoal: Optional[Union[ActionConversionGoal, CustomEventConversionGoal]] = None
     dateRange: Optional[DateRange] = None
     doPathCleaning: Optional[bool] = None
@@ -5723,7 +5687,7 @@ class RetentionQuery(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -5771,7 +5735,7 @@ class StickinessQuery(BaseModel):
         extra="forbid",
     )
     compareFilter: Optional[CompareFilter] = Field(default=None, description="Compare to date range")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -5822,7 +5786,10 @@ class TrendsQuery(BaseModel):
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
     breakdownFilter: Optional[BreakdownFilter] = Field(default=None, description="Breakdown of the events and actions")
     compareFilter: Optional[CompareFilter] = Field(default=None, description="Compare to date range")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    conversionGoal: Optional[Union[ActionConversionGoal, CustomEventConversionGoal]] = Field(
+        default=None, description="Whether we should be comparing against a specific conversion goal"
+    )
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -5888,6 +5855,7 @@ class CachedExperimentTrendsQueryResponse(BaseModel):
     )
     significance_code: ExperimentSignificanceCode
     significant: bool
+    stats_version: Optional[int] = None
     timezone: str
     variants: list[ExperimentVariantTrendsBaseStats]
 
@@ -5905,6 +5873,7 @@ class Response10(BaseModel):
     probability: dict[str, float]
     significance_code: ExperimentSignificanceCode
     significant: bool
+    stats_version: Optional[int] = None
     variants: list[ExperimentVariantTrendsBaseStats]
 
 
@@ -6009,6 +5978,7 @@ class ExperimentTrendsQueryResponse(BaseModel):
     probability: dict[str, float]
     significance_code: ExperimentSignificanceCode
     significant: bool
+    stats_version: Optional[int] = None
     variants: list[ExperimentVariantTrendsBaseStats]
 
 
@@ -6018,7 +5988,7 @@ class FunnelsQuery(BaseModel):
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
     breakdownFilter: Optional[BreakdownFilter] = Field(default=None, description="Breakdown of the events and actions")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -6070,7 +6040,7 @@ class InsightsQueryBaseFunnelsQueryResponse(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -6109,7 +6079,7 @@ class InsightsQueryBaseLifecycleQueryResponse(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -6148,7 +6118,7 @@ class InsightsQueryBasePathsQueryResponse(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -6187,7 +6157,7 @@ class InsightsQueryBaseRetentionQueryResponse(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -6226,7 +6196,7 @@ class InsightsQueryBaseTrendsQueryResponse(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -6265,7 +6235,7 @@ class LifecycleQuery(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
@@ -6337,6 +6307,7 @@ class QueryResponseAlternative16(BaseModel):
     probability: dict[str, float]
     significance_code: ExperimentSignificanceCode
     significant: bool
+    stats_version: Optional[int] = None
     variants: list[ExperimentVariantTrendsBaseStats]
 
 
@@ -6368,6 +6339,7 @@ class QueryResponseAlternative27(BaseModel):
     probability: dict[str, float]
     significance_code: ExperimentSignificanceCode
     significant: bool
+    stats_version: Optional[int] = None
     variants: list[ExperimentVariantTrendsBaseStats]
 
 
@@ -6551,6 +6523,7 @@ class ExperimentTrendsQuery(BaseModel):
     )
     name: Optional[str] = None
     response: Optional[ExperimentTrendsQueryResponse] = None
+    stats_version: Optional[int] = None
 
 
 class FunnelPathsFilter(BaseModel):
@@ -6605,7 +6578,7 @@ class PathsQuery(BaseModel):
         extra="forbid",
     )
     aggregation_group_type_index: Optional[int] = Field(default=None, description="Groups aggregation")
-    dateRange: Optional[InsightDateRange] = Field(default=None, description="Date range for the query")
+    dateRange: Optional[DateRange] = Field(default=None, description="Date range for the query")
     filterTestAccounts: Optional[bool] = Field(
         default=False, description="Exclude internal and test users by applying the respective filters"
     )
diff --git a/posthog/session_recordings/queries/session_recording_list_from_filters.py b/posthog/session_recordings/queries/session_recording_list_from_filters.py
deleted file mode 100644
index 38522ae4d18ce..0000000000000
--- a/posthog/session_recordings/queries/session_recording_list_from_filters.py
+++ /dev/null
@@ -1,651 +0,0 @@
-import re
-from typing import Any, NamedTuple, cast, Optional, Union
-from datetime import datetime, timedelta
-
-import posthoganalytics
-
-from posthog.hogql import ast
-from posthog.hogql.ast import CompareOperation
-from posthog.hogql.constants import HogQLGlobalSettings
-from posthog.hogql.parser import parse_select
-from posthog.hogql.property import entity_to_expr, property_to_expr
-from posthog.hogql.query import execute_hogql_query
-from posthog.hogql_queries.insights.paginators import HogQLHasMorePaginator
-from posthog.models import Team, Property
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
-from posthog.models.filters.mixins.utils import cached_property
-from posthog.models.property import PropertyGroup
-from posthog.schema import QueryTiming, HogQLQueryModifiers, PersonsOnEventsMode
-from posthog.session_recordings.queries.session_replay_events import ttl_days
-from posthog.constants import TREND_FILTER_TYPE_ACTIONS
-
-import structlog
-
-logger = structlog.get_logger(__name__)
-
-
-def is_event_property(p: Property) -> bool:
-    return p.type == "event" or (p.type == "hogql" and bool(re.search(r"(?<!person\.)properties\.", p.key)))
-
-
-def is_person_property(p: Property) -> bool:
-    return p.type == "person" or (p.type == "hogql" and "person.properties" in p.key)
-
-
-def is_group_property(p: Property) -> bool:
-    return p.type == "group"
-
-
-def is_cohort_property(p: Property) -> bool:
-    return "cohort" in p.type
-
-
-class SessionRecordingQueryResult(NamedTuple):
-    results: list
-    has_more_recording: bool
-    timings: list[QueryTiming] | None = None
-
-
-class UnexpectedQueryProperties(Exception):
-    def __init__(self, remaining_properties: PropertyGroup | None):
-        self.remaining_properties = remaining_properties
-        super().__init__(f"Unexpected properties in query: {remaining_properties}")
-
-
-class SessionRecordingListFromFilters:
-    SESSION_RECORDINGS_DEFAULT_LIMIT = 50
-
-    _team: Team
-    _filter: SessionRecordingsFilter
-
-    BASE_QUERY: str = """
-        SELECT s.session_id,
-            any(s.team_id),
-            any(s.distinct_id),
-            min(s.min_first_timestamp) as start_time,
-            max(s.max_last_timestamp) as end_time,
-            dateDiff('SECOND', start_time, end_time) as duration,
-            argMinMerge(s.first_url) as first_url,
-            sum(s.click_count) as click_count,
-            sum(s.keypress_count) as keypress_count,
-            sum(s.mouse_activity_count) as mouse_activity_count,
-            sum(s.active_milliseconds)/1000 as active_seconds,
-            (duration - active_seconds) as inactive_seconds,
-            sum(s.console_log_count) as console_log_count,
-            sum(s.console_warn_count) as console_warn_count,
-            sum(s.console_error_count) as console_error_count,
-            {ongoing_selection},
-            round((
-            ((sum(s.active_milliseconds) / 1000 + sum(s.click_count) + sum(s.keypress_count) + sum(s.console_error_count))) -- intent
-            /
-            ((sum(s.mouse_activity_count) + dateDiff('SECOND', start_time, end_time) + sum(s.console_error_count) + sum(s.console_log_count) + sum(s.console_warn_count)))
-            * 100
-            ), 2) as activity_score
-        FROM raw_session_replay_events s
-        WHERE {where_predicates}
-        GROUP BY session_id
-        HAVING {having_predicates}
-        ORDER BY {order_by} DESC
-        """
-
-    @staticmethod
-    def _data_to_return(results: list[Any] | None) -> list[dict[str, Any]]:
-        default_columns = [
-            "session_id",
-            "team_id",
-            "distinct_id",
-            "start_time",
-            "end_time",
-            "duration",
-            "first_url",
-            "click_count",
-            "keypress_count",
-            "mouse_activity_count",
-            "active_seconds",
-            "inactive_seconds",
-            "console_log_count",
-            "console_warn_count",
-            "console_error_count",
-            "ongoing",
-            "activity_score",
-        ]
-
-        return [
-            {
-                **dict(zip(default_columns, row[: len(default_columns)])),
-            }
-            for row in results or []
-        ]
-
-    def __init__(
-        self,
-        team: Team,
-        filter: SessionRecordingsFilter,
-        hogql_query_modifiers: Optional[HogQLQueryModifiers],
-        **_,
-    ):
-        self._team = team
-        self._filter = filter
-        self._paginator = HogQLHasMorePaginator(
-            limit=filter.limit or self.SESSION_RECORDINGS_DEFAULT_LIMIT, offset=filter.offset or 0
-        )
-        self._hogql_query_modifiers = hogql_query_modifiers
-
-    @property
-    def ttl_days(self):
-        return ttl_days(self._team)
-
-    def run(self) -> SessionRecordingQueryResult:
-        query = self.get_query()
-
-        paginated_response = self._paginator.execute_hogql_query(
-            # TODO I guess the paginator needs to know how to handle union queries or all callers are supposed to collapse them or .... 🤷
-            query=cast(ast.SelectQuery, query),
-            team=self._team,
-            query_type="SessionRecordingListQuery",
-            modifiers=self._hogql_query_modifiers,
-            settings=HogQLGlobalSettings(allow_experimental_analyzer=False),  # This needs to be turned on eventually
-        )
-
-        return SessionRecordingQueryResult(
-            results=(self._data_to_return(self._paginator.results)),
-            has_more_recording=self._paginator.has_more(),
-            timings=paginated_response.timings,
-        )
-
-    def get_query(self):
-        return parse_select(
-            self.BASE_QUERY,
-            {
-                # Check if the most recent _timestamp is within five minutes of the current time
-                # proxy for a live session
-                "ongoing_selection": ast.Alias(
-                    alias="ongoing",
-                    expr=ast.CompareOperation(
-                        left=ast.Call(name="max", args=[ast.Field(chain=["s", "_timestamp"])]),
-                        right=ast.Constant(
-                            # provided in a placeholder, so we can pass now from python to make tests easier 🙈
-                            value=datetime.utcnow() - timedelta(minutes=5),
-                        ),
-                        op=ast.CompareOperationOp.GtEq,
-                    ),
-                ),
-                "order_by": self._order_by_clause(),
-                "where_predicates": self._where_predicates(),
-                "having_predicates": self._having_predicates(),
-            },
-        )
-
-    def _order_by_clause(self) -> ast.Field:
-        return ast.Field(chain=[self._filter.order])
-
-    def _where_predicates(self) -> Union[ast.And, ast.Or]:
-        exprs: list[ast.Expr] = [
-            ast.CompareOperation(
-                op=ast.CompareOperationOp.GtEq,
-                left=ast.Field(chain=["s", "min_first_timestamp"]),
-                right=ast.Constant(value=datetime.utcnow() - timedelta(days=self.ttl_days)),
-            )
-        ]
-
-        person_id_compare_operation = PersonsIdCompareOperation(self._team, self._filter, self.ttl_days).get_operation()
-        if person_id_compare_operation:
-            exprs.append(person_id_compare_operation)
-
-        # we check for session_ids type not for truthiness since we want to allow empty lists
-        if isinstance(self._filter.session_ids, list):
-            exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.In,
-                    left=ast.Field(chain=["session_id"]),
-                    right=ast.Constant(value=self._filter.session_ids),
-                )
-            )
-
-        if self._filter.date_from:
-            exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.GtEq,
-                    left=ast.Field(chain=["s", "min_first_timestamp"]),
-                    right=ast.Constant(value=self._filter.date_from),
-                )
-            )
-        if self._filter.date_to:
-            exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.LtEq,
-                    left=ast.Field(chain=["s", "min_first_timestamp"]),
-                    right=ast.Constant(value=self._filter.date_to),
-                )
-            )
-
-        optional_exprs: list[ast.Expr] = []
-
-        # if in PoE mode then we should be pushing person property queries into here
-        events_sub_query = ReplayFiltersEventsSubQuery(self._team, self._filter).get_query_for_session_id_matching()
-        if events_sub_query:
-            optional_exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.In,
-                    left=ast.Field(chain=["s", "session_id"]),
-                    right=events_sub_query,
-                )
-            )
-
-        # we want to avoid a join to persons since we don't ever need to select from them,
-        # so we create our own persons sub query here
-        # if PoE mode is on then this will be handled in the events subquery, and we don't need to do anything here
-        person_subquery = PersonsPropertiesSubQuery(self._team, self._filter, self.ttl_days).get_query()
-        if person_subquery:
-            optional_exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.In,
-                    left=ast.Field(chain=["s", "distinct_id"]),
-                    right=person_subquery,
-                )
-            )
-
-        cohort_subquery = CohortPropertyGroupsSubQuery(self._team, self._filter, self.ttl_days).get_query()
-        if cohort_subquery:
-            optional_exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.In,
-                    left=ast.Field(chain=["s", "distinct_id"]),
-                    right=cohort_subquery,
-                )
-            )
-
-        remaining_properties = self._strip_person_and_event_and_cohort_properties(self._filter.property_groups)
-        if remaining_properties:
-            posthoganalytics.capture_exception(UnexpectedQueryProperties(remaining_properties))
-            optional_exprs.append(property_to_expr(remaining_properties, team=self._team, scope="replay"))
-
-        if self._filter.console_log_filters.values:
-            console_logs_subquery = ast.SelectQuery(
-                select=[ast.Field(chain=["log_source_id"])],
-                select_from=ast.JoinExpr(table=ast.Field(chain=["console_logs_log_entries"])),
-                where=self._filter.ast_operand(
-                    exprs=[
-                        property_to_expr(self._filter.console_log_filters, team=self._team),
-                    ]
-                ),
-            )
-
-            optional_exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.In,
-                    left=ast.Field(chain=["session_id"]),
-                    right=console_logs_subquery,
-                )
-            )
-
-        if optional_exprs:
-            exprs.append(self._filter.ast_operand(exprs=optional_exprs))
-
-        return ast.And(exprs=exprs)
-
-    def _having_predicates(self) -> ast.Expr:
-        return property_to_expr(self._filter.having_predicates, team=self._team, scope="replay")
-
-    def _strip_person_and_event_and_cohort_properties(self, property_group: PropertyGroup) -> PropertyGroup | None:
-        property_groups_to_keep = [
-            g
-            for g in property_group.flat
-            if not is_event_property(g)
-            and not is_person_property(g)
-            and not is_group_property(g)
-            and not is_cohort_property(g)
-        ]
-
-        return (
-            PropertyGroup(
-                type=self._filter.property_operand,
-                values=property_groups_to_keep,
-            )
-            if property_groups_to_keep
-            else None
-        )
-
-
-def poe_is_active(team: Team) -> bool:
-    return team.person_on_events_mode is not None and team.person_on_events_mode != PersonsOnEventsMode.DISABLED
-
-
-class PersonsPropertiesSubQuery:
-    _team: Team
-    _filter: SessionRecordingsFilter
-    _ttl_days: int
-
-    def __init__(self, team: Team, filter: SessionRecordingsFilter, ttl_days: int):
-        self._team = team
-        self._filter = filter
-        self._ttl_days = ttl_days
-
-    def get_query(self) -> ast.SelectQuery | ast.SelectSetQuery | None:
-        if self.person_properties and not poe_is_active(self._team):
-            return parse_select(
-                """
-                SELECT distinct_id
-                FROM person_distinct_ids
-                WHERE {where_predicates}
-                """,
-                {
-                    "where_predicates": self._where_predicates,
-                },
-            )
-        else:
-            return None
-
-    @cached_property
-    def person_properties(self) -> PropertyGroup | None:
-        person_property_groups = [g for g in self._filter.property_groups.flat if is_person_property(g)]
-        return (
-            PropertyGroup(
-                type=self._filter.property_operand,
-                values=person_property_groups,
-            )
-            if person_property_groups
-            else None
-        )
-
-    @cached_property
-    def _where_predicates(self) -> ast.Expr:
-        return (
-            property_to_expr(self.person_properties, team=self._team)
-            if self.person_properties
-            else ast.Constant(value=True)
-        )
-
-
-class CohortPropertyGroupsSubQuery:
-    _team: Team
-    _filter: SessionRecordingsFilter
-    _ttl_days: int
-
-    raw_cohort_to_distinct_id = """
-    SELECT
-    distinct_id
-FROM raw_person_distinct_ids
-WHERE distinct_id in (SELECT distinct_id FROM raw_person_distinct_ids WHERE 1=1 AND {cohort_predicate})
-GROUP BY distinct_id
-HAVING argMax(is_deleted, version) = 0 AND {cohort_predicate}
-    """
-
-    def __init__(self, team: Team, filter: SessionRecordingsFilter, ttl_days: int):
-        self._team = team
-        self._filter = filter
-        self._ttl_days = ttl_days
-
-    def get_query(self) -> ast.SelectQuery | ast.SelectSetQuery | None:
-        if self.cohort_properties:
-            return parse_select(
-                self.raw_cohort_to_distinct_id,
-                {"cohort_predicate": property_to_expr(self.cohort_properties, team=self._team, scope="replay")},
-            )
-
-        return None
-
-    @cached_property
-    def cohort_properties(self) -> PropertyGroup | None:
-        cohort_property_groups = [g for g in self._filter.property_groups.flat if is_cohort_property(g)]
-        return (
-            PropertyGroup(
-                type=self._filter.property_operand,
-                values=cohort_property_groups,
-            )
-            if cohort_property_groups
-            else None
-        )
-
-
-class PersonsIdCompareOperation:
-    _team: Team
-    _filter: SessionRecordingsFilter
-    _ttl_days: int
-
-    def __init__(self, team: Team, filter: SessionRecordingsFilter, ttl_days: int):
-        self._team = team
-        self._filter = filter
-        self._ttl_days = ttl_days
-
-    def get_operation(self) -> CompareOperation | None:
-        q = self.get_query()
-        if not q:
-            return None
-
-        if poe_is_active(self._team):
-            return ast.CompareOperation(
-                op=ast.CompareOperationOp.In,
-                left=ast.Field(chain=["session_id"]),
-                right=q,
-            )
-        else:
-            return ast.CompareOperation(
-                op=ast.CompareOperationOp.In,
-                left=ast.Field(chain=["distinct_id"]),
-                right=q,
-            )
-
-    def get_query(self) -> ast.SelectQuery | ast.SelectSetQuery | None:
-        if not self._filter.person_uuid:
-            return None
-
-        # anchor to python now so that tests can freeze time
-        now = datetime.utcnow()
-
-        if poe_is_active(self._team):
-            return parse_select(
-                """
-                select
-                    distinct `$session_id`
-                from
-                    events
-                where
-                    person_id = {person_id}
-                    and timestamp <= {now}
-                    and timestamp >= {ttl_date}
-                    and timestamp >= {date_from}
-                    and timestamp <= {date_to}
-                    and notEmpty(`$session_id`)
-                """,
-                {
-                    "person_id": ast.Constant(value=self._filter.person_uuid),
-                    "ttl_days": ast.Constant(value=self._ttl_days),
-                    "date_from": ast.Constant(value=self._filter.date_from),
-                    "date_to": ast.Constant(value=self._filter.date_to),
-                    "now": ast.Constant(value=now),
-                    "ttl_date": ast.Constant(value=now - timedelta(days=self._ttl_days)),
-                },
-            )
-        else:
-            return parse_select(
-                """
-                SELECT distinct_id
-                FROM person_distinct_ids
-                WHERE person_id = {person_id}
-                """,
-                {
-                    "person_id": ast.Constant(value=self._filter.person_uuid),
-                },
-            )
-
-
-class ReplayFiltersEventsSubQuery:
-    _team: Team
-    _filter: SessionRecordingsFilter
-
-    @property
-    def ttl_days(self):
-        return ttl_days(self._team)
-
-    def __init__(
-        self,
-        team: Team,
-        filter: SessionRecordingsFilter,
-        hogql_query_modifiers: Optional[HogQLQueryModifiers] = None,
-    ):
-        self._team = team
-        self._filter = filter
-        self._hogql_query_modifiers = hogql_query_modifiers
-
-    @cached_property
-    def _event_predicates(self):
-        event_exprs: list[ast.Expr] = []
-        event_names: set[int | str] = set()
-
-        for entity in self._filter.entities:
-            if entity.type == TREND_FILTER_TYPE_ACTIONS:
-                action = entity.get_action()
-                event_names.update([ae for ae in action.get_step_events() if ae and ae not in event_names])
-            else:
-                if entity.id and entity.id not in event_names:
-                    event_names.add(entity.id)
-
-            # TODO: we're not passing the "right" type in here - should we change the signature or do something else?
-            entity_exprs = [entity_to_expr(entity=entity)]  # type: ignore
-
-            if entity.property_groups:
-                entity_exprs.append(property_to_expr(entity.property_groups, team=self._team, scope="replay_entity"))
-
-            event_exprs.append(ast.And(exprs=entity_exprs))
-
-        return event_exprs, list(event_names)
-
-    def _select_from_events(self, select_expr: ast.Expr) -> ast.SelectQuery:
-        return ast.SelectQuery(
-            select=[select_expr],
-            select_from=ast.JoinExpr(
-                table=ast.Field(chain=["events"]),
-            ),
-            where=self._where_predicates(),
-            having=self._having_predicates(),
-            group_by=[ast.Field(chain=["$session_id"])],
-        )
-
-    def get_query_for_session_id_matching(self) -> ast.SelectQuery | ast.SelectSetQuery | None:
-        use_poe = poe_is_active(self._team) and self.person_properties
-        if self._filter.entities or self.event_properties or self.group_properties or use_poe:
-            return self._select_from_events(ast.Alias(alias="session_id", expr=ast.Field(chain=["$session_id"])))
-        else:
-            return None
-
-    def get_query_for_event_id_matching(self) -> ast.SelectQuery | ast.SelectSetQuery:
-        return self._select_from_events(ast.Call(name="groupUniqArray", args=[ast.Field(chain=["uuid"])]))
-
-    def get_event_ids_for_session(self) -> SessionRecordingQueryResult:
-        query = self.get_query_for_event_id_matching()
-
-        hogql_query_response = execute_hogql_query(
-            query=query,
-            team=self._team,
-            query_type="SessionRecordingMatchingEventsForSessionQuery",
-            modifiers=self._hogql_query_modifiers,
-        )
-
-        flattened_results = [str(uuid) for row in hogql_query_response.results for uuid in row[0]]
-
-        return SessionRecordingQueryResult(
-            results=flattened_results,
-            has_more_recording=False,
-            timings=hogql_query_response.timings,
-        )
-
-    def _where_predicates(self) -> ast.Expr:
-        exprs: list[ast.Expr] = [
-            ast.Call(
-                name="notEmpty",
-                args=[ast.Field(chain=["$session_id"])],
-            ),
-            # regardless of any other filters limit between TTL and current time
-            ast.CompareOperation(
-                op=ast.CompareOperationOp.GtEq,
-                left=ast.Field(chain=["timestamp"]),
-                right=ast.Constant(value=datetime.now() - timedelta(days=self.ttl_days)),
-            ),
-            ast.CompareOperation(
-                op=ast.CompareOperationOp.LtEq,
-                left=ast.Field(chain=["timestamp"]),
-                right=ast.Call(name="now", args=[]),
-            ),
-        ]
-
-        # TRICKY: we're adding a buffer to the date range to ensure we get all the events
-        # you can start sending us events before the session starts
-        if self._filter.date_from:
-            exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.GtEq,
-                    left=ast.Field(chain=["timestamp"]),
-                    right=ast.Constant(value=self._filter.date_from - timedelta(minutes=2)),
-                )
-            )
-
-        # but we don't want to include events after date_to if provided
-        if self._filter.date_to:
-            exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.LtEq,
-                    left=ast.Field(chain=["timestamp"]),
-                    right=ast.Constant(value=self._filter.date_to),
-                )
-            )
-
-        (event_where_exprs, _) = self._event_predicates
-        if event_where_exprs:
-            # we OR all events in the where and use hasAll / hasAny in the HAVING clause
-            exprs.append(ast.Or(exprs=event_where_exprs))
-
-        if self.event_properties:
-            exprs.append(property_to_expr(self.event_properties, team=self._team, scope="replay"))
-
-        if self.group_properties:
-            exprs.append(property_to_expr(self.group_properties, team=self._team))
-
-        if self._team.person_on_events_mode and self.person_properties:
-            exprs.append(property_to_expr(self.person_properties, team=self._team, scope="event"))
-
-        if self._filter.session_ids:
-            exprs.append(
-                ast.CompareOperation(
-                    op=ast.CompareOperationOp.In,
-                    left=ast.Field(chain=["$session_id"]),
-                    right=ast.Constant(value=self._filter.session_ids),
-                )
-            )
-
-        return ast.And(exprs=exprs)
-
-    def _having_predicates(self) -> ast.Expr:
-        (_, event_names) = self._event_predicates
-
-        if event_names:
-            return ast.Call(
-                name="hasAll" if self._filter._operand == "AND" else "hasAny",
-                args=[
-                    ast.Call(name="groupUniqArray", args=[ast.Field(chain=["event"])]),
-                    # KLUDGE: sorting only so that snapshot tests are consistent
-                    ast.Constant(value=sorted(event_names)),
-                ],
-            )
-
-        return ast.Constant(value=True)
-
-    @cached_property
-    def event_properties(self):
-        return [g for g in self._filter.property_groups.flat if is_event_property(g)]
-
-    @cached_property
-    def group_properties(self):
-        return [g for g in self._filter.property_groups.flat if is_group_property(g)]
-
-    @cached_property
-    def person_properties(self) -> PropertyGroup | None:
-        person_property_groups = [g for g in self._filter.property_groups.flat if is_person_property(g)]
-        return (
-            PropertyGroup(
-                type=self._filter.property_operand,
-                values=person_property_groups,
-            )
-            if person_property_groups
-            else None
-        )
diff --git a/posthog/session_recordings/queries/session_recording_list_from_query.py b/posthog/session_recordings/queries/session_recording_list_from_query.py
index fe08fb85590f2..d53c99682edad 100644
--- a/posthog/session_recordings/queries/session_recording_list_from_query.py
+++ b/posthog/session_recordings/queries/session_recording_list_from_query.py
@@ -247,7 +247,7 @@ def _order_by_clause(self) -> ast.Field:
     @cached_property
     def query_date_range(self):
         return QueryDateRange(
-            date_range=DateRange(date_from=self._query.date_from, date_to=self._query.date_to),
+            date_range=DateRange(date_from=self._query.date_from, date_to=self._query.date_to, explicitDate=True),
             team=self._team,
             interval=None,
             now=datetime.now(),
@@ -303,7 +303,10 @@ def _where_predicates(self) -> Union[ast.And, ast.Or]:
         if events_sub_query:
             optional_exprs.append(
                 ast.CompareOperation(
-                    op=ast.CompareOperationOp.In,
+                    # this hits the distributed events table from the distributed session_replay_events table
+                    # so we should use GlobalIn
+                    # see https://clickhouse.com/docs/en/sql-reference/operators/in#distributed-subqueries
+                    op=ast.CompareOperationOp.GlobalIn,
                     left=ast.Field(chain=["s", "session_id"]),
                     right=events_sub_query,
                 )
@@ -498,7 +501,10 @@ def get_operation(self) -> CompareOperation | None:
 
         if poe_is_active(self._team):
             return ast.CompareOperation(
-                op=ast.CompareOperationOp.In,
+                # this hits the distributed events table from the distributed session_replay_events table
+                # so we should use GlobalIn
+                # see https://clickhouse.com/docs/en/sql-reference/operators/in#distributed-subqueries
+                op=ast.CompareOperationOp.GlobalIn,
                 left=ast.Field(chain=["session_id"]),
                 right=q,
             )
diff --git a/posthog/session_recordings/queries/session_recording_properties.py b/posthog/session_recordings/queries/session_recording_properties.py
deleted file mode 100644
index 2d2ef187c0407..0000000000000
--- a/posthog/session_recordings/queries/session_recording_properties.py
+++ /dev/null
@@ -1,106 +0,0 @@
-from datetime import timedelta
-from typing import TYPE_CHECKING, Any, NamedTuple
-
-from posthog.client import sync_execute
-from posthog.models.event.util import parse_properties
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
-from posthog.queries.event_query import EventQuery
-
-if TYPE_CHECKING:
-    from posthog.models import Team
-
-
-class EventFiltersSQL(NamedTuple):
-    aggregate_select_clause: str
-    aggregate_having_clause: str
-    where_conditions: str
-    params: dict[str, Any]
-
-
-class SessionRecordingProperties(EventQuery):
-    _filter: SessionRecordingsFilter
-    _session_ids: list[str]
-
-    SESSION_RECORDING_PROPERTIES_ALLOWLIST = {
-        "$os",
-        "$browser",
-        "$device_type",
-        "$current_url",
-        "$host",
-        "$pathname",
-        "$geoip_country_code",
-        "$geoip_country_name",
-    }
-
-    # First $pageview event in a recording is used to extract metadata (brower, location, etc.) without
-    # having to return all events.
-    _core_single_pageview_event_query = """
-         SELECT
-            "$session_id" AS session_id,
-            any(properties) AS properties
-         FROM events
-         PREWHERE
-             team_id = %(team_id)s
-             AND event IN ['$pageview', '$autocapture']
-             {session_ids_clause}
-             {events_timestamp_clause}
-             GROUP BY session_id
-    """
-
-    def __init__(self, team: "Team", session_ids: list[str], filter: SessionRecordingsFilter):
-        super().__init__(team=team, filter=filter)
-        self._session_ids = sorted(session_ids)  # Sort for stable queries
-
-    def _determine_should_join_distinct_ids(self) -> None:
-        self._should_join_distinct_ids = False
-
-    # We want to select events beyond the range of the recording to handle the case where
-    # a recording spans the time boundaries
-    def _get_events_timestamp_clause(self) -> tuple[str, dict[str, Any]]:
-        timestamp_clause = ""
-        timestamp_params = {}
-        if self._filter.date_from:
-            timestamp_clause += "\nAND timestamp >= %(event_start_time)s"
-            timestamp_params["event_start_time"] = self._filter.date_from - timedelta(hours=12)
-        if self._filter.date_to:
-            timestamp_clause += "\nAND timestamp <= %(event_end_time)s"
-            timestamp_params["event_end_time"] = self._filter.date_to + timedelta(hours=12)
-        return timestamp_clause, timestamp_params
-
-    def format_session_recording_id_filters(self) -> tuple[str, dict]:
-        where_conditions = "AND session_id IN %(session_ids)s"
-        return where_conditions, {"session_ids": self._session_ids}
-
-    def get_query(self) -> tuple[str, dict[str, Any]]:
-        base_params = {"team_id": self._team_id}
-        (
-            events_timestamp_clause,
-            events_timestamp_params,
-        ) = self._get_events_timestamp_clause()
-        (
-            session_ids_clause,
-            session_ids_params,
-        ) = self.format_session_recording_id_filters()
-
-        return (
-            self._core_single_pageview_event_query.format(
-                events_timestamp_clause=events_timestamp_clause,
-                session_ids_clause=session_ids_clause,
-            ),
-            {**base_params, **events_timestamp_params, **session_ids_params},
-        )
-
-    def _data_to_return(self, results: list[Any]) -> list[dict[str, Any]]:
-        return [
-            {
-                "session_id": row[0],
-                "properties": parse_properties(row[1], self.SESSION_RECORDING_PROPERTIES_ALLOWLIST),
-            }
-            for row in results
-        ]
-
-    def run(self) -> list:
-        query, query_params = self.get_query()
-        query_results = sync_execute(query, query_params)
-        session_recording_properties = self._data_to_return(query_results)
-        return session_recording_properties
diff --git a/posthog/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_filters.ambr b/posthog/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_filters.ambr
deleted file mode 100644
index 82e70f3063a2b..0000000000000
--- a/posthog/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_filters.ambr
+++ /dev/null
@@ -1,5812 +0,0 @@
-# serializer version: 1
-# name: TestSessionRecordingsListFromFilters.test_action_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-28 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-27 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0), ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_action_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-28 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-27 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_action_filter.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-28 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-27 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_action_filter.3
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-28 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-27 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_all_filters_at_once
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-22 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-04 23:59:59.999999', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-22 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-04 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-21 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-04 23:59:59.999999', 6, 'UTC')), or(and(equals(events.event, '$pageview'), 1), and(equals(events.event, 'custom-event'), 1)))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'custom-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_any_event_filter_with_properties
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(1, 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_any_event_filter_with_properties.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(1, ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_any_event_filter_with_properties.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(1, ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_any_event_filter_with_properties_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(1, 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_any_event_filter_with_properties_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(1, ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_any_event_filter_with_properties_materialized.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(1, ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_active_sessions
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING ifNull(greater(duration, 60), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_active_sessions.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING ifNull(greater(active_seconds, '60'), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_active_sessions.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING ifNull(greater(inactive_seconds, '60'), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_with_ordering
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY active_seconds DESC
-  LIMIT 4
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_with_ordering.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY console_error_count DESC
-  LIMIT 4
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_with_ordering.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 4
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_with_paging
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 2
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_with_paging.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 2
-  OFFSET 1 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_basic_query_with_paging.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 2
-  OFFSET 2 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_date_from_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_date_from_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-30 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_date_from_filter_cannot_search_before_ttl
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 12:41:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-12 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 12:46:00.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_date_from_filter_cannot_search_before_ttl.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 12:41:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 12:46:00.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_date_from_filter_cannot_search_before_ttl.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 12:41:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-10 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 12:46:00.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_date_to_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-28 23:59:59.999999', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_date_to_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 23:59:59.999999', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_duration_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING ifNull(greater(duration, 60), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_duration_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING ifNull(less(duration, 60), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$autocapture'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$autocapture']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_has_ttl_applied_too
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_has_ttl_applied_too.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_active_sessions
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING ifNull(greater(duration, 60), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_active_sessions.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING ifNull(greater(active_seconds, 60), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_group_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM groups
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(groups.team_id, 99999), equals(index, 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY groups.group_type_index, groups.group_key) AS events__group_1 ON equals(events.`$group_1`, events__group_1.key)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__group_1.properties___name, 'org one'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_group_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM groups
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(groups.team_id, 99999), equals(index, 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY groups.group_type_index, groups.group_key) AS events__group_1 ON equals(events.`$group_1`, events__group_1.key)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(events__group_1.properties___name, 'org one'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_group_filter.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM groups
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(groups.team_id, 99999), equals(index, 2))
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY groups.group_type_index, groups.group_key) AS events__group_2 ON equals(events.`$group_2`, events__group_2.key)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(events__group_2.properties___name, 'org one'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_event_properties_test_accounts_excluded
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_event_properties_test_accounts_excluded.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_event_properties_test_accounts_excluded.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_event_properties_test_accounts_excluded_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_event_properties_test_accounts_excluded_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_event_properties_test_accounts_excluded_materialized.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_person_properties
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'bla'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_person_properties.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'something else'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_properties
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_properties.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_properties_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_hogql_properties_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_matching_on_session_id
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_matching_on_session_id.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$autocapture'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$autocapture']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties.3
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Safari'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties_materialized.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_properties_materialized.3
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Safari'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_test_accounts_excluded
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1), and(ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_test_accounts_excluded.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_test_accounts_excluded_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1), and(ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_test_accounts_excluded_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_event_filter_with_two_events_and_multiple_teams
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), 1), and(equals(events.event, '$pageleave'), 1)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageleave', '$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_by_console_text_0__key_level_value_warn_error_operator_exact_type_log_entry_key_message_value_message_4_operator_icontains_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE or(or(ifNull(equals(console_logs_log_entries.level, 'warn'), 0), ifNull(equals(console_logs_log_entries.level, 'error'), 0)), ifNull(ilike(console_logs_log_entries.message, '%message 4%'), 0)))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_by_console_text_1__key_level_value_warn_error_operator_exact_type_log_entry_key_message_value_message_5_operator_icontains_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(or(ifNull(equals(console_logs_log_entries.level, 'warn'), 0), ifNull(equals(console_logs_log_entries.level, 'error'), 0)), ifNull(ilike(console_logs_log_entries.message, '%message 5%'), 0)))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_by_console_text_2__key_level_value_info_operator_exact_type_log_entry_key_message_value_message_5_operator_icontains_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(ifNull(equals(console_logs_log_entries.level, 'info'), 0), ifNull(ilike(console_logs_log_entries.message, '%message 5%'), 0)))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_by_snapshot_source
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING ifNull(equals(argMinMerge(s.snapshot_source), 'web'), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_by_snapshot_source.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING ifNull(equals(argMinMerge(s.snapshot_source), 'mobile'), 0)
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_console_errors
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'error'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_console_errors.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'info'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_console_logs
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'info'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_console_logs.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'warn'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_console_warns
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'warn'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_console_warns.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'info'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_mixed_console_counts
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE or(ifNull(equals(console_logs_log_entries.level, 'warn'), 0), ifNull(equals(console_logs_log_entries.level, 'error'), 0)))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_for_recordings_with_mixed_console_counts.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'info'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_on_session_ids
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999),
-            ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0),
-            in(s.session_id,
-               ['00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000001' /* ... */],
-               ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0),
-               ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_on_session_ids.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999),
-            ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0),
-            in(s.session_id,
-               ['00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000001' /* ... */],
-               ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0),
-               ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_cohort_properties
-  '''
-  
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = NULL
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_cohort_properties.1
-  '''
-  /* cohort_calculation: */
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = 0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_cohort_properties.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_events_and_cohorts
-  '''
-  
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = NULL
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_events_and_cohorts.1
-  '''
-  /* cohort_calculation: */
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = 0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_events_and_cohorts.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), and(in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING hasAll(groupUniqArray(events.event), ['$pageview']))), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))))))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_events_and_cohorts.3
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), and(in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, 'custom_event'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING hasAll(groupUniqArray(events.event), ['custom_event']))), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))))))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_person_properties_exact
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla@gmail.com'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_person_properties_not_contains
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), ifNull(notILike(events__person.properties___email, '%gmail.com%'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties
-  '''
-  
-  SELECT count(DISTINCT person_id)
-  FROM person_static_cohort
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties.1
-  '''
-  
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = NULL
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties.2
-  '''
-  /* cohort_calculation: */
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = 0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties.3
-  '''
-  
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = NULL
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties.4
-  '''
-  /* cohort_calculation: */
-  SELECT count(DISTINCT person_id)
-  FROM cohortpeople
-  WHERE team_id = 99999
-    AND cohort_id = 99999
-    AND version = 0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties.5
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (SELECT person_static_cohort.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FROM person_static_cohort
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WHERE and(equals(person_static_cohort.team_id, 99999), equals(person_static_cohort.cohort_id, 99999))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT person_static_cohort.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM person_static_cohort
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(person_static_cohort.team_id, 99999), equals(person_static_cohort.cohort_id, 99999))))))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties.6
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_filter_with_static_and_dynamic_cohort_properties.7
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(person_distinct_id2.team_id, 99999), 1, and(in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person_static_cohort.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person_static_cohort
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE and(equals(person_static_cohort.team_id, 99999), equals(person_static_cohort.cohort_id, 99999)))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), and(in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT person_static_cohort.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             FROM person_static_cohort
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(person_static_cohort.team_id, 99999), equals(person_static_cohort.cohort_id, 99999)))))))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_listing_ignores_future_replays
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-08-30 11:55:01.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-09 12:00:01.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-23 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-30 12:00:01.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_multiple_event_filters
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), 1), and(equals(events.event, 'new-event'), 1)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_multiple_event_filters.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), 1), and(equals(events.event, 'new-event2'), 1)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event2']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_multiple_event_filters.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), 1), and(equals(events.event, 'new-event2'), 1)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'new-event2']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_multiple_event_filters.3
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'bar'), ''), 'null'), '^"|"$', ''), 'foo'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_multiple_event_filters.4
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, 'new-event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_multiple_event_filters.5
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, 'new-event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'new-event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_event_filters
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), 1), and(equals(events.event, 'custom_event'), 1)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'custom_event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_event_filters.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), 1), and(equals(events.event, 'custom_event'), 1)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'custom_event']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_filters_0__key_level_value_warn_operator_exact_type_log_entry_key_message_value_random_operator_exact_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(ifNull(equals(console_logs_log_entries.level, 'warn'), 0), ifNull(equals(console_logs_log_entries.message, 'random'), 0)))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_filters_1__key_level_value_info_operator_exact_type_log_entry_key_message_value_random_operator_exact_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(ifNull(equals(console_logs_log_entries.level, 'info'), 0), ifNull(equals(console_logs_log_entries.message, 'random'), 0)))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_filters_2__key_level_value_warn_operator_exact_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.level, 'warn'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_filters_3__key_message_value_random_operator_exact_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.message AS message
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE ifNull(equals(console_logs_log_entries.message, 'random'), 0))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_filters_4__key_level_value_warn_operator_exact_type_log_entry_key_message_value_random_operator_exact_type_log_entry_
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT console_logs_log_entries.log_source_id AS log_source_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(log_entries.team_id, 99999), equals(log_entries.log_source, 'session_replay'))) AS console_logs_log_entries
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE or(ifNull(equals(console_logs_log_entries.level, 'warn'), 0), ifNull(equals(console_logs_log_entries.message, 'random'), 0)))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_mandatory_filters
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_mandatory_filters.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_mandatory_filters.2
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id, ['session_id_one']), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1), in(events.`$session_id`, ['session_id_one']))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_mandatory_filters.3
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id, ['session_id_two']), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1), in(events.`$session_id`, ['session_id_two']))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_person_filters
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), and(ifNull(equals(events__person.properties___email, 'test@posthog.com'), 0), ifNull(equals(events__person.properties___email, 'david@posthog.com'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_operand_or_person_filters.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-24 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), or(ifNull(equals(events__person.properties___email, 'test@posthog.com'), 0), ifNull(equals(events__person.properties___email, 'david@posthog.com'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_ordering
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_ordering.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY mouse_activity_count DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_person_id_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_sessions_with_current_data
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-25 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_host_property_test_account_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_host_property_test_account_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(not(match(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$host'), ''), 'null'), '^"|"$', '')), '^(localhost|127\\.0\\.0\\.1)($|:)')), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_host_property_test_account_filter_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_host_property_test_account_filter_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(not(match(toString(nullIf(nullIf(events.`mat_$host`, ''), 'null')), '^(localhost|127\\.0\\.0\\.1)($|:)')), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter_allowing_denormalized_props
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter_allowing_denormalized_props.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter_allowing_denormalized_props_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter_allowing_denormalized_props_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_event_property_test_account_filter_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_event_property_test_account_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_event_property_test_account_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'true'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_event_property_test_account_filter_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_event_property_test_account_filter_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'true'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_person_property_test_account_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_person_property_test_account_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_person_property_test_account_filter_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_hogql_person_property_test_account_filter_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_person_property_test_account_filter
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_person_property_test_account_filter.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_person_property_test_account_filter_materialized
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
-# name: TestSessionRecordingsListFromFilters.test_top_level_person_property_test_account_filter_materialized.1
-  '''
-  SELECT s.session_id AS session_id,
-         any(s.team_id),
-         any(s.distinct_id),
-         min(toTimeZone(s.min_first_timestamp, 'UTC')) AS start_time,
-         max(toTimeZone(s.max_last_timestamp, 'UTC')) AS end_time,
-         dateDiff('SECOND', start_time, end_time) AS duration,
-         argMinMerge(s.first_url) AS first_url,
-         sum(s.click_count) AS click_count,
-         sum(s.keypress_count) AS keypress_count,
-         sum(s.mouse_activity_count) AS mouse_activity_count,
-         divide(sum(s.active_milliseconds), 1000) AS active_seconds,
-         minus(duration, active_seconds) AS inactive_seconds,
-         sum(s.console_log_count) AS console_log_count,
-         sum(s.console_warn_count) AS console_warn_count,
-         sum(s.console_error_count) AS console_error_count,
-         ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
-         round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
-  FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-13 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
-  GROUP BY s.session_id
-  HAVING 1
-  ORDER BY start_time DESC
-  LIMIT 51
-  OFFSET 0 SETTINGS readonly=2,
-                    max_execution_time=60,
-                    allow_experimental_object_type=1,
-                    format_csv_allow_double_quotes=0,
-                    max_ast_elements=4000000,
-                    max_expanded_ast_elements=4000000,
-                    max_bytes_before_external_group_by=0,
-                    allow_experimental_analyzer=0
-  '''
-# ---
diff --git a/posthog/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr b/posthog/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr
index 34f0b42e60970..df35cd7773af4 100644
--- a/posthog/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr
+++ b/posthog/session_recordings/queries/test/__snapshots__/test_session_recording_list_from_query.ambr
@@ -19,12 +19,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'custom-event'), and(ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0), ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'custom-event'), and(ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0), ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -59,12 +59,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -99,12 +99,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -139,12 +139,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-01-03 23:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-01-04 00:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-14 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2022-12-31 23:58:00.000000', 6, 'UTC')), and(and(equals(events.event, 'custom-event'), and(ifNull(equals(nullIf(nullIf(events.`$session_id`, ''), 'null'), 'test_action_filter-session-one'), 0), ifNull(equals(nullIf(nullIf(events.`$window_id`, ''), 'null'), 'test_action_filter-window-id'), 0))), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['custom-event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -179,21 +179,21 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-22 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-04 00:00:00.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-22 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-04 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-21 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-04 00:00:00.000000', 6, 'UTC')), or(equals(events.event, 'custom-event'), equals(events.event, '$pageview')))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'custom-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-22 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-04 00:00:00.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-22 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-04 00:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-21 23:58:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-04 00:00:00.000000', 6, 'UTC')), or(equals(events.event, 'custom-event'), equals(events.event, '$pageview')))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'custom-event']))))
   GROUP BY s.session_id
   HAVING ifNull(greater(duration, 60.0), 0)
   ORDER BY start_time DESC
@@ -228,12 +228,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), 1)
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), 1)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -268,12 +268,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -308,12 +308,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -348,12 +348,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), 1)
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), 1)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -388,12 +388,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -428,12 +428,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(1, ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -468,7 +468,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -503,7 +503,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING ifNull(greater(duration, 60.0), 0)
   ORDER BY start_time DESC
@@ -538,7 +538,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING ifNull(greater(active_seconds, '60'), 0)
   ORDER BY start_time DESC
@@ -573,7 +573,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING ifNull(greater(inactive_seconds, '60'), 0)
   ORDER BY start_time DESC
@@ -608,7 +608,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY active_seconds DESC
@@ -643,7 +643,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY console_error_count DESC
@@ -678,7 +678,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -713,7 +713,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -748,7 +748,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -783,7 +783,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -818,7 +818,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -853,7 +853,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-30 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-30 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -888,7 +888,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 12:41:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-12 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-12 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 12:46:00.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -923,7 +923,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 12:41:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 12:46:00.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -958,7 +958,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 12:41:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-10 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 12:46:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-10 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 12:46:00.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -993,7 +993,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-28 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-28 00:00:00.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1028,7 +1028,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 12:46:00.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1063,7 +1063,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING ifNull(greater(duration, 60.0), 0)
   ORDER BY start_time DESC
@@ -1098,7 +1098,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING ifNull(less(duration, 60.0), 0)
   ORDER BY start_time DESC
@@ -1133,12 +1133,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1173,12 +1173,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$autocapture'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$autocapture']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$autocapture'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$autocapture']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1213,12 +1213,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1253,7 +1253,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1288,12 +1288,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING ifNull(greater(duration, 60.0), 0)
   ORDER BY start_time DESC
@@ -1328,12 +1328,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING ifNull(greater(active_seconds, 60.0), 0)
   ORDER BY start_time DESC
@@ -1368,17 +1368,17 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM groups
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(groups.team_id, 99999), equals(index, 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY groups.group_type_index, groups.group_key) AS events__group_1 ON equals(events.`$group_1`, events__group_1.key)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__group_1.properties___name, 'org one'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM groups
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(groups.team_id, 99999), equals(index, 1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY groups.group_type_index, groups.group_key) AS events__group_1 ON equals(events.`$group_1`, events__group_1.key)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__group_1.properties___name, 'org one'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1413,17 +1413,17 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM groups
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(groups.team_id, 99999), equals(index, 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY groups.group_type_index, groups.group_key) AS events__group_1 ON equals(events.`$group_1`, events__group_1.key)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__group_1.properties___name, 'org one'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM groups
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(groups.team_id, 99999), equals(index, 1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY groups.group_type_index, groups.group_key) AS events__group_1 ON equals(events.`$group_1`, events__group_1.key)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__group_1.properties___name, 'org one'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1458,17 +1458,17 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM groups
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(groups.team_id, 99999), equals(index, 2))
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY groups.group_type_index, groups.group_key) AS events__group_2 ON equals(events.`$group_2`, events__group_2.key)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__group_2.properties___name, 'org one'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(groups.group_properties, 'name'), ''), 'null'), '^"|"$', ''), toTimeZone(groups._timestamp, 'UTC')) AS properties___name, groups.group_type_index AS index, groups.group_key AS key
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM groups
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(groups.team_id, 99999), equals(index, 2))
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY groups.group_type_index, groups.group_key) AS events__group_2 ON equals(events.`$group_2`, events__group_2.key)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__group_2.properties___name, 'org one'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1503,12 +1503,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1543,27 +1543,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1598,27 +1598,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1653,12 +1653,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1693,27 +1693,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1748,27 +1748,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1803,27 +1803,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'bla'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'bla'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1858,27 +1858,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'something else'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(events__person.properties___email, 'something else'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1913,12 +1913,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1953,12 +1953,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -1993,12 +1993,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2033,12 +2033,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2073,12 +2073,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2113,12 +2113,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$autocapture'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$autocapture']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$autocapture'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$autocapture']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2153,12 +2153,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2193,12 +2193,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Firefox'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2233,12 +2233,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2273,12 +2273,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Safari'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Safari'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2313,12 +2313,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2353,12 +2353,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, '$pageview'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Firefox'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2393,12 +2393,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Chrome'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2433,12 +2433,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Safari'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(equals(events.event, 'a_different_event'), ifNull(equals(nullIf(nullIf(events.`mat_$browser`, ''), 'null'), 'Safari'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['a_different_event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2473,27 +2473,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), and(ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), and(ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2528,12 +2528,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2568,27 +2568,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), and(ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), and(ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$browser'), ''), 'null'), '^"|"$', ''), 'Chrome'), 0)), ifNull(notILike(events__person.properties___email, '%@posthog.com%'), 1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2623,12 +2623,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2663,12 +2663,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, '$pageleave')))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageleave', '$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, '$pageleave')))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageleave', '$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -2703,7 +2703,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
@@ -2744,7 +2744,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
@@ -2785,7 +2785,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
@@ -2826,7 +2826,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
@@ -2867,7 +2867,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING ifNull(equals(argMinMerge(s.snapshot_source), 'web'), 0)
   ORDER BY start_time DESC
@@ -2902,7 +2902,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING ifNull(equals(argMinMerge(s.snapshot_source), 'mobile'), 0)
   ORDER BY start_time DESC
@@ -2937,7 +2937,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -2978,7 +2978,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -3019,7 +3019,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -3060,7 +3060,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -3101,7 +3101,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -3142,7 +3142,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -3183,7 +3183,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -3224,7 +3224,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -3270,7 +3270,7 @@
             in(s.session_id,
                ['00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000001' /* ... */],
                ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0),
-               ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+               ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3310,7 +3310,7 @@
             in(s.session_id,
                ['00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000001' /* ... */],
                ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0),
-               ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+               ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3365,7 +3365,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 23:59:59.999999', 6, 'UTC')), 0), in(s.distinct_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT person_distinct_id2.distinct_id AS distinct_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id2
                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
@@ -3434,26 +3434,26 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 23:59:59.999999', 6, 'UTC')), 0), and(in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING hasAll(groupUniqArray(events.event), ['$pageview']))), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))))))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), and(globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                      (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                       FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                       WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                       GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                       HAVING hasAll(groupUniqArray(events.event), ['$pageview']))), in(s.distinct_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (SELECT person_distinct_id2.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           FROM person_distinct_id2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (SELECT person_distinct_id2.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       FROM person_distinct_id2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT cohortpeople.person_id AS person_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM cohortpeople
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           GROUP BY person_distinct_id2.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (SELECT cohortpeople.person_id AS person_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       FROM cohortpeople
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))))))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3488,26 +3488,26 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 23:59:59.999999', 6, 'UTC')), 0), and(in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                 FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                 WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-17 23:58:00.000000', 6, 'UTC')), equals(events.event, 'custom_event'))
-                                                                                                                                                                                                                                                                                                                                                                                                                                 GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                 HAVING hasAll(groupUniqArray(events.event), ['custom_event']))), in(s.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT person_distinct_id2.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM person_distinct_id2
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GROUP BY person_distinct_id2.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (SELECT cohortpeople.person_id AS person_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FROM cohortpeople
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))))))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), and(globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                      (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                       FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                       WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-08-17 23:58:00.000000', 6, 'UTC')), equals(events.event, 'custom_event'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                       GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                       HAVING hasAll(groupUniqArray(events.event), ['custom_event']))), in(s.distinct_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT person_distinct_id2.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (SELECT person_distinct_id2.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FROM person_distinct_id2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WHERE and(equals(person_distinct_id2.team_id, 99999), 1, in(person_distinct_id2.person_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT cohortpeople.person_id AS person_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM cohortpeople
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0))))))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GROUP BY person_distinct_id2.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HAVING and(ifNull(equals(argMax(person_distinct_id2.is_deleted, person_distinct_id2.version), 0), 0), in(person_distinct_id2.person_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (SELECT cohortpeople.person_id AS person_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FROM cohortpeople
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WHERE and(equals(cohortpeople.team_id, 99999), equals(cohortpeople.cohort_id, 99999), equals(cohortpeople.version, 0)))))))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3542,27 +3542,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla@gmail.com'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla@gmail.com'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3597,27 +3597,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(notILike(events__person.properties___email, '%gmail.com%'), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), ifNull(notILike(events__person.properties___email, '%gmail.com%'), 1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3701,7 +3701,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 23:59:59.999999', 6, 'UTC')), 0), in(s.distinct_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT person_distinct_id2.distinct_id AS distinct_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id2
                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
@@ -3750,7 +3750,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 23:59:59.999999', 6, 'UTC')), 0), in(s.distinct_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT person_distinct_id2.distinct_id AS distinct_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id2
                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
@@ -3799,7 +3799,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-08-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 23:59:59.999999', 6, 'UTC')), 0), in(s.distinct_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-07-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-08-21 20:00:00.000000', 6, 'UTC')), 0), in(s.distinct_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT person_distinct_id2.distinct_id AS distinct_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM person_distinct_id2
                                                                                                                                                                                                                                                                                                                                                                                                                              WHERE and(equals(person_distinct_id2.team_id, 99999), in(person_distinct_id2.distinct_id,
@@ -3854,7 +3854,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2023-08-30 11:55:01.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-09 12:00:01.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-27 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-30 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-09 12:00:01.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-27 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2023-08-30 12:00:01.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3889,12 +3889,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'new-event')))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'new-event')))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3929,12 +3929,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'new-event2')))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event2']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'new-event2')))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event2']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -3969,12 +3969,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'new-event2')))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'new-event2']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'new-event2')))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'new-event2']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4009,12 +4009,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'bar'), ''), 'null'), '^"|"$', ''), 'foo'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'bar'), ''), 'null'), '^"|"$', ''), 'foo'), 0))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4049,12 +4049,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, 'new-event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, 'new-event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'new-event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4089,12 +4089,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, 'new-event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0))))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'new-event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(and(equals(events.event, '$pageview'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0)), and(equals(events.event, 'new-event'), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'foo'), ''), 'null'), '^"|"$', ''), 'bar'), 0))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'new-event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4129,12 +4129,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'custom_event')))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'custom_event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'custom_event')))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview', 'custom_event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4169,12 +4169,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'custom_event')))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'custom_event']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(equals(events.event, '$pageview'), equals(events.event, 'custom_event')))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAny(groupUniqArray(events.event), ['$pageview', 'custom_event']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4209,7 +4209,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
@@ -4250,7 +4250,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
@@ -4291,7 +4291,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level
@@ -4332,7 +4332,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.message AS message
@@ -4373,7 +4373,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
                                                                                                                                                                                                                                                                                                                                                                                                                             (SELECT console_logs_log_entries.log_source_id AS log_source_id
                                                                                                                                                                                                                                                                                                                                                                                                                              FROM
                                                                                                                                                                                                                                                                                                                                                                                                                                (SELECT log_entries.log_source_id AS log_source_id, log_entries.level AS level, log_entries.message AS message
@@ -4414,21 +4414,21 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4463,21 +4463,21 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4512,12 +4512,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id, ['session_id_one']), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), in(events.`$session_id`, ['session_id_one']))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id, ['session_id_one']), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), in(events.`$session_id`, ['session_id_one']))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4552,12 +4552,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id, ['session_id_two']), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), in(events.`$session_id`, ['session_id_two']))
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id, ['session_id_two']), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'), in(events.`$session_id`, ['session_id_two']))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         HAVING hasAny(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4592,27 +4592,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(ifNull(equals(events__person.properties___email, 'test@posthog.com'), 0), ifNull(equals(events__person.properties___email, 'david@posthog.com'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), and(ifNull(equals(events__person.properties___email, 'test@posthog.com'), 0), ifNull(equals(events__person.properties___email, 'david@posthog.com'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4647,27 +4647,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(ifNull(equals(events__person.properties___email, 'test@posthog.com'), 0), ifNull(equals(events__person.properties___email, 'david@posthog.com'), 0)))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-28 23:58:00.000000', 6, 'UTC')), or(ifNull(equals(events__person.properties___email, 'test@posthog.com'), 0), ifNull(equals(events__person.properties___email, 'david@posthog.com'), 0)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4702,7 +4702,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4737,7 +4737,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY mouse_activity_count DESC
@@ -4772,16 +4772,16 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                       (SELECT DISTINCT events.`$session_id` AS `$session_id`
-                                                                                                                                                                        FROM events
-                                                                                                                                                                        LEFT OUTER JOIN
-                                                                                                                                                                          (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                           FROM person_distinct_id_overrides
-                                                                                                                                                                           WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                           GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                           HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                        WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                             (SELECT DISTINCT events.`$session_id` AS `$session_id`
+                                                                                                                                                                              FROM events
+                                                                                                                                                                              LEFT OUTER JOIN
+                                                                                                                                                                                (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                 FROM person_distinct_id_overrides
+                                                                                                                                                                                 WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                 GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                 HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                              WHERE and(equals(events.team_id, 99999), ifNull(equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), '00000000-0000-0000-0000-000000000000'), 0), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), notEmpty(events.`$session_id`)))), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4816,7 +4816,7 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-01 13:41:23.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 23:59:59.999999', 6, 'UTC')), 0))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-11 13:46:23.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-29 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-01 13:46:23.000000', 6, 'UTC')), 0))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4851,12 +4851,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4891,12 +4891,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(not(match(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$host'), ''), 'null'), '^"|"$', '')), '^(localhost|127\\.0\\.0\\.1)($|:)')), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(not(match(toString(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, '$host'), ''), 'null'), '^"|"$', '')), '^(localhost|127\\.0\\.0\\.1)($|:)')), 1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4931,12 +4931,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -4971,12 +4971,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(not(match(toString(nullIf(nullIf(events.`mat_$host`, ''), 'null')), '^(localhost|127\\.0\\.0\\.1)($|:)')), 1))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(not(match(toString(nullIf(nullIf(events.`mat_$host`, ''), 'null')), '^(localhost|127\\.0\\.0\\.1)($|:)')), 1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5011,12 +5011,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5051,12 +5051,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5091,12 +5091,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5131,12 +5131,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'false'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5171,12 +5171,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5211,12 +5211,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5251,12 +5251,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5291,12 +5291,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'false'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5331,12 +5331,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5371,12 +5371,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'true'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(events.properties, 'is_internal_user'), ''), 'null'), '^"|"$', ''), 'true'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5411,12 +5411,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5451,12 +5451,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'true'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(nullIf(nullIf(events.mat_is_internal_user, ''), 'null'), 'true'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5491,12 +5491,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5531,27 +5531,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5586,12 +5586,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5626,27 +5626,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5681,12 +5681,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5721,27 +5721,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, replaceRegexpAll(nullIf(nullIf(JSONExtractRaw(person.properties, 'email'), ''), 'null'), '^"|"$', '') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5776,12 +5776,12 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), equals(events.event, '$pageview'))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING hasAll(groupUniqArray(events.event), ['$pageview']))))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
@@ -5816,27 +5816,27 @@
          ifNull(greaterOrEquals(max(toTimeZone(s._timestamp, 'UTC')), toDateTime64('2021-01-21 19:55:00.000000', 6, 'UTC')), 0) AS ongoing,
          round(multiply(divide(plus(plus(plus(divide(sum(s.active_milliseconds), 1000), sum(s.click_count)), sum(s.keypress_count)), sum(s.console_error_count)), plus(plus(plus(plus(sum(s.mouse_activity_count), dateDiff('SECOND', start_time, end_time)), sum(s.console_error_count)), sum(s.console_log_count)), sum(s.console_warn_count))), 100), 2) AS activity_score
   FROM session_replay_events AS s
-  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 23:59:59.999999', 6, 'UTC')), 0), in(s.session_id,
-                                                                                                                                                                                                                                                                                                                                                                                                                            (SELECT events.`$session_id` AS session_id
-                                                                                                                                                                                                                                                                                                                                                                                                                             FROM events
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT OUTER JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person_distinct_id_overrides
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE equals(person_distinct_id_overrides.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                GROUP BY person_distinct_id_overrides.distinct_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             LEFT JOIN
-                                                                                                                                                                                                                                                                                                                                                                                                                               (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
-                                                                                                                                                                                                                                                                                                                                                                                                                                FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, max(person.version) AS version
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person.team_id, 99999)
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person.id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
-                                                                                                                                                                                                                                                                                                                                                                                                                             WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
-                                                                                                                                                                                                                                                                                                                                                                                                                             GROUP BY events.`$session_id`
-                                                                                                                                                                                                                                                                                                                                                                                                                             HAVING 1)))
+  WHERE and(equals(s.team_id, 99999), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), 0), ifNull(greaterOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-18 00:00:00.000000', 6, 'UTC')), 0), ifNull(lessOrEquals(toTimeZone(s.min_first_timestamp, 'UTC'), toDateTime64('2021-01-21 20:00:00.000000', 6, 'UTC')), 0), globalIn(s.session_id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                  (SELECT events.`$session_id` AS session_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                   FROM events
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT OUTER JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT argMax(person_distinct_id_overrides.person_id, person_distinct_id_overrides.version) AS person_id, person_distinct_id_overrides.distinct_id AS distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person_distinct_id_overrides
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE equals(person_distinct_id_overrides.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                      GROUP BY person_distinct_id_overrides.distinct_id
+                                                                                                                                                                                                                                                                                                                                                                                                                                      HAVING ifNull(equals(argMax(person_distinct_id_overrides.is_deleted, person_distinct_id_overrides.version), 0), 0) SETTINGS optimize_aggregation_in_order=1) AS events__override ON equals(events.distinct_id, events__override.distinct_id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   LEFT JOIN
+                                                                                                                                                                                                                                                                                                                                                                                                                                     (SELECT person.id AS id, nullIf(nullIf(person.pmat_email, ''), 'null') AS properties___email
+                                                                                                                                                                                                                                                                                                                                                                                                                                      FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                      WHERE and(equals(person.team_id, 99999), ifNull(in(tuple(person.id, person.version),
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (SELECT person.id AS id, max(person.version) AS version
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FROM person
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WHERE equals(person.team_id, 99999)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GROUP BY person.id
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HAVING and(ifNull(equals(argMax(person.is_deleted, person.version), 0), 0), ifNull(less(argMax(toTimeZone(person.created_at, 'UTC'), person.version), plus(now64(6, 'UTC'), toIntervalDay(1))), 0)))), 0)) SETTINGS optimize_aggregation_in_order=1) AS events__person ON equals(if(not(empty(events__override.distinct_id)), events__override.person_id, events.person_id), events__person.id)
+                                                                                                                                                                                                                                                                                                                                                                                                                                   WHERE and(equals(events.team_id, 99999), notEmpty(events.`$session_id`), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2020-12-31 20:00:00.000000', 6, 'UTC')), lessOrEquals(toTimeZone(events.timestamp, 'UTC'), now64(6, 'UTC')), greaterOrEquals(toTimeZone(events.timestamp, 'UTC'), toDateTime64('2021-01-17 23:58:00.000000', 6, 'UTC')), ifNull(equals(events__person.properties___email, 'bla'), 0))
+                                                                                                                                                                                                                                                                                                                                                                                                                                   GROUP BY events.`$session_id`
+                                                                                                                                                                                                                                                                                                                                                                                                                                   HAVING 1)))
   GROUP BY s.session_id
   HAVING 1
   ORDER BY start_time DESC
diff --git a/posthog/session_recordings/queries/test/test_session_recording_list_from_filters.py b/posthog/session_recordings/queries/test/test_session_recording_list_from_filters.py
deleted file mode 100644
index f8ce2daccf3d5..0000000000000
--- a/posthog/session_recordings/queries/test/test_session_recording_list_from_filters.py
+++ /dev/null
@@ -1,4164 +0,0 @@
-from datetime import datetime
-from typing import Literal
-from unittest.mock import ANY
-from uuid import uuid4
-
-from dateutil.relativedelta import relativedelta
-from django.utils.timezone import now
-from freezegun import freeze_time
-from parameterized import parameterized
-
-from posthog.clickhouse.client import sync_execute
-from posthog.clickhouse.log_entries import TRUNCATE_LOG_ENTRIES_TABLE_SQL
-from posthog.constants import AvailableFeature
-from posthog.models import Cohort, GroupTypeMapping, Person
-from posthog.models.action import Action
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
-from posthog.models.group.util import create_group
-from posthog.models.team import Team
-from posthog.session_recordings.queries.session_recording_list_from_filters import (
-    SessionRecordingListFromFilters,
-    SessionRecordingQueryResult,
-)
-from posthog.session_recordings.queries.session_replay_events import ttl_days
-from posthog.session_recordings.queries.test.session_replay_sql import (
-    produce_replay_summary,
-)
-from posthog.session_recordings.sql.session_replay_event_sql import (
-    TRUNCATE_SESSION_REPLAY_EVENTS_TABLE_SQL,
-)
-from posthog.test.base import (
-    APIBaseTest,
-    ClickhouseTestMixin,
-    _create_event,
-    also_test_with_materialized_columns,
-    flush_persons_and_events,
-    snapshot_clickhouse_queries,
-)
-
-
-@freeze_time("2021-01-01T13:46:23")
-class TestSessionRecordingsListFromFilters(ClickhouseTestMixin, APIBaseTest):
-    def setUp(self):
-        super().setUp()
-        sync_execute(TRUNCATE_SESSION_REPLAY_EVENTS_TABLE_SQL())
-        sync_execute(TRUNCATE_LOG_ENTRIES_TABLE_SQL)
-
-    def create_action(self, name, team_id=None, properties=None):
-        if team_id is None:
-            team_id = self.team.pk
-        if properties is None:
-            properties = []
-        action = Action.objects.create(
-            team_id=team_id,
-            name=name,
-            steps_json=[
-                {
-                    "event": name,
-                    "properties": properties,
-                }
-            ],
-        )
-        return action
-
-    def create_event(
-        self,
-        distinct_id,
-        timestamp,
-        team=None,
-        event_name="$pageview",
-        properties=None,
-    ):
-        if team is None:
-            team = self.team
-        if properties is None:
-            properties = {"$os": "Windows 95", "$current_url": "aloha.com/2"}
-        return _create_event(
-            team=team,
-            event=event_name,
-            timestamp=timestamp,
-            distinct_id=distinct_id,
-            properties=properties,
-        )
-
-    def _filter_recordings_by(self, recordings_filter: dict | None = None) -> SessionRecordingQueryResult:
-        the_filter = SessionRecordingsFilter(team=self.team, data=recordings_filter or {})
-        session_recording_list_instance = SessionRecordingListFromFilters(
-            filter=the_filter, team=self.team, hogql_query_modifiers=None
-        )
-        return session_recording_list_instance.run()
-
-    @property
-    def an_hour_ago(self):
-        return (now() - relativedelta(hours=1)).replace(microsecond=0, second=0)
-
-    @snapshot_clickhouse_queries
-    def test_basic_query(self):
-        user = "test_basic_query-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_one = f"test_basic_query-{str(uuid4())}"
-        session_id_two = f"test_basic_query-{str(uuid4())}"
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago.isoformat().replace("T", " "),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=20)).isoformat().replace("T", " "),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=50 * 1000 * 0.5,  # 50% of the total expected duration
-        )
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=10)),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=50)),
-            distinct_id=user,
-            first_url="https://a-different-url.com",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=0,  # 30% of the total expected duration
-        )
-
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=20)),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=2000)),
-            distinct_id=user,
-            first_url="https://another-url.com",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=1980 * 1000 * 0.4,  # 40% of the total expected duration
-        )
-
-        session_recordings, more_recordings_available, _ = self._filter_recordings_by({"no_filter": None})
-
-        assert session_recordings == [
-            {
-                "session_id": session_id_two,
-                "activity_score": 40.16,
-                "team_id": self.team.pk,
-                "distinct_id": user,
-                "click_count": 2,
-                "keypress_count": 2,
-                "mouse_activity_count": 2,
-                "duration": 1980,
-                "active_seconds": 792.0,
-                "inactive_seconds": 1188.0,
-                "start_time": self.an_hour_ago + relativedelta(seconds=20),
-                "end_time": self.an_hour_ago + relativedelta(seconds=2000),
-                "first_url": "https://another-url.com",
-                "console_log_count": 0,
-                "console_warn_count": 0,
-                "console_error_count": 0,
-                "ongoing": 1,
-            },
-            {
-                "session_id": session_id_one,
-                "activity_score": 61.11,
-                "team_id": self.team.pk,
-                "distinct_id": user,
-                "click_count": 4,
-                "keypress_count": 4,
-                "mouse_activity_count": 4,
-                "duration": 50,
-                "active_seconds": 25.0,
-                "inactive_seconds": 25.0,
-                "start_time": self.an_hour_ago,
-                "end_time": self.an_hour_ago + relativedelta(seconds=50),
-                "first_url": "https://example.io/home",
-                "console_log_count": 0,
-                "console_warn_count": 0,
-                "console_error_count": 0,
-                "ongoing": 1,
-            },
-        ]
-
-        assert more_recordings_available is False
-
-    @snapshot_clickhouse_queries
-    def test_basic_query_active_sessions(
-        self,
-    ):
-        user = "test_basic_query-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_total_is_61 = f"test_basic_query_active_sessions-total-{str(uuid4())}"
-        session_id_active_is_61 = f"test_basic_query_active_sessions-active-{str(uuid4())}"
-        session_id_inactive_is_61 = f"test_basic_query_active_sessions-inactive-{str(uuid4())}"
-
-        produce_replay_summary(
-            session_id=session_id_total_is_61,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago.isoformat().replace("T", " "),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=61)).isoformat().replace("T", " "),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=59000,
-        )
-
-        produce_replay_summary(
-            session_id=session_id_active_is_61,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=59)),
-            distinct_id=user,
-            first_url="https://a-different-url.com",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=61000,
-        )
-
-        produce_replay_summary(
-            session_id=session_id_inactive_is_61,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=61)),
-            distinct_id=user,
-            first_url="https://a-different-url.com",
-            click_count=0,
-            keypress_count=0,
-            mouse_activity_count=0,
-            active_milliseconds=0,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "having_predicates": '[{"type":"recording","key":"duration","value":60,"operator":"gt"}]',
-            }
-        )
-
-        assert sorted(
-            [(s["session_id"], s["duration"], s["active_seconds"]) for s in session_recordings],
-            key=lambda x: x[0],
-        ) == [
-            (session_id_inactive_is_61, 61, 0.0),
-            (session_id_total_is_61, 61, 59.0),
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "having_predicates": '[{"type":"recording","key":"active_seconds","value":"60","operator":"gt"}]',
-            }
-        )
-
-        assert [(s["session_id"], s["duration"], s["active_seconds"]) for s in session_recordings] == [
-            (session_id_active_is_61, 59, 61.0)
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "having_predicates": '[{"type":"recording","key":"inactive_seconds","value":"60","operator":"gt"}]',
-            }
-        )
-
-        assert [(s["session_id"], s["duration"], s["inactive_seconds"]) for s in session_recordings] == [
-            (session_id_inactive_is_61, 61, 61.0)
-        ]
-
-    @snapshot_clickhouse_queries
-    def test_sessions_with_current_data(
-        self,
-    ):
-        user = "test_sessions_with_current_data-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_inactive = f"test_sessions_with_current_data-inactive-{str(uuid4())}"
-        session_id_active = f"test_sessions_with_current_data-active-{str(uuid4())}"
-
-        produce_replay_summary(
-            session_id=session_id_inactive,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=60),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=59000,
-            kafka_timestamp=(datetime.utcnow() - relativedelta(minutes=6)),
-        )
-
-        produce_replay_summary(
-            session_id=session_id_active,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=60),
-            distinct_id=user,
-            first_url="https://a-different-url.com",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=61000,
-            kafka_timestamp=(datetime.utcnow() - relativedelta(minutes=3)),
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by({})
-        assert sorted(
-            [(s["session_id"], s["ongoing"]) for s in session_recordings],
-            key=lambda x: x[0],
-        ) == [
-            (session_id_active, 1),
-            (session_id_inactive, 0),
-        ]
-
-    @snapshot_clickhouse_queries
-    def test_basic_query_with_paging(self):
-        user = "test_basic_query_with_paging-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_one = f"id_one_test_basic_query_with_paging-{str(uuid4())}"
-        session_id_two = f"id_two_test_basic_query_with_paging-{str(uuid4())}"
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago.isoformat().replace("T", " "),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=20)).isoformat().replace("T", " "),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=50 * 1000 * 0.5,  # 50% of the total expected duration
-        )
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=10)),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=50)),
-            distinct_id=user,
-            first_url="https://a-different-url.com",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=0,  # 30% of the total expected duration
-        )
-
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=20)),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=2000)),
-            distinct_id=user,
-            first_url="https://another-url.com",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=1980 * 1000 * 0.4,  # 40% of the total expected duration
-        )
-
-        (session_recordings, more_recordings_available, _) = self._filter_recordings_by(
-            {"no_filter": None, "limit": 1, "offset": 0}
-        )
-
-        assert session_recordings == [
-            {
-                "activity_score": 40.16,
-                "session_id": session_id_two,
-                "team_id": self.team.pk,
-                "distinct_id": user,
-                "click_count": 2,
-                "keypress_count": 2,
-                "mouse_activity_count": 2,
-                "duration": 1980,
-                "active_seconds": 792.0,
-                "inactive_seconds": 1188.0,
-                "start_time": self.an_hour_ago + relativedelta(seconds=20),
-                "end_time": self.an_hour_ago + relativedelta(seconds=2000),
-                "first_url": "https://another-url.com",
-                "console_log_count": 0,
-                "console_warn_count": 0,
-                "console_error_count": 0,
-                "ongoing": 1,
-            }
-        ]
-
-        assert more_recordings_available is True
-
-        (session_recordings, more_recordings_available, _) = self._filter_recordings_by(
-            {"no_filter": None, "limit": 1, "offset": 1}
-        )
-
-        assert session_recordings == [
-            {
-                "session_id": session_id_one,
-                "activity_score": 61.11,
-                "team_id": self.team.pk,
-                "distinct_id": user,
-                "click_count": 4,
-                "keypress_count": 4,
-                "mouse_activity_count": 4,
-                "duration": 50,
-                "active_seconds": 25.0,
-                "inactive_seconds": 25.0,
-                "start_time": self.an_hour_ago,
-                "end_time": self.an_hour_ago + relativedelta(seconds=50),
-                "first_url": "https://example.io/home",
-                "console_log_count": 0,
-                "console_warn_count": 0,
-                "console_error_count": 0,
-                "ongoing": 1,
-            },
-        ]
-
-        assert more_recordings_available is False
-
-        (session_recordings, more_recordings_available, _) = self._filter_recordings_by(
-            {"no_filter": None, "limit": 1, "offset": 2}
-        )
-
-        assert session_recordings == []
-
-        assert more_recordings_available is False
-
-    @snapshot_clickhouse_queries
-    def test_basic_query_with_ordering(self):
-        user = "test_basic_query_with_ordering-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_one = f"test_basic_query_with_ordering-session-1-{str(uuid4())}"
-        session_id_two = f"test_basic_query_with_ordering-session-2-{str(uuid4())}"
-
-        session_one_start = self.an_hour_ago + relativedelta(seconds=10)
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=session_one_start,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=50)),
-            distinct_id=user,
-            console_error_count=1000,
-            active_milliseconds=1,  # most errors, but the least activity
-        )
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=session_one_start,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=50)),
-            distinct_id=user,
-            console_error_count=12,
-            active_milliseconds=1,  # most errors, but the least activity
-        )
-
-        session_two_start = self.an_hour_ago
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.pk,
-            # starts before session one
-            first_timestamp=session_two_start,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=50)),
-            distinct_id=user,
-            console_error_count=430,
-            active_milliseconds=1000,  # most activity, but the least errors
-        )
-
-        (session_recordings) = self._filter_recordings_by(
-            {"no_filter": None, "limit": 3, "offset": 0, "order": "active_seconds"}
-        )
-
-        ordered_by_activity = [(r["session_id"], r["active_seconds"]) for r in session_recordings.results]
-        assert ordered_by_activity == [(session_id_two, 1.0), (session_id_one, 0.002)]
-
-        (session_recordings) = self._filter_recordings_by(
-            {"no_filter": None, "limit": 3, "offset": 0, "order": "console_error_count"}
-        )
-
-        ordered_by_errors = [(r["session_id"], r["console_error_count"]) for r in session_recordings.results]
-        assert ordered_by_errors == [(session_id_one, 1012), (session_id_two, 430)]
-
-        (session_recordings) = self._filter_recordings_by(
-            {"no_filter": None, "limit": 3, "offset": 0, "order": "start_time"}
-        )
-
-        ordered_by_default = [(r["session_id"], r["start_time"]) for r in session_recordings.results]
-        assert ordered_by_default == [(session_id_one, session_one_start), (session_id_two, session_two_start)]
-
-    def test_first_url_selection(self):
-        user = "test_first_url_selection-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_one = f"first-url-on-first-event-{str(uuid4())}"
-        session_id_two = f"first-url-not-on-first-event-{str(uuid4())}"
-        session_id_three = f"no-url-from-many-{str(uuid4())}"
-        session_id_four = f"events-inserted-out-of-order-{str(uuid4())}"
-
-        # session one has the first url on the first event
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=20),
-            first_url="https://on-first-event.com",
-        )
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=10),
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=20),
-            first_url="https://on-second-event.com",
-        )
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=20),
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=40),
-            first_url="https://on-third-event.com",
-        )
-
-        # session two has no URL on the first event
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.pk,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=10)),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=50)),
-            first_url=None,
-        )
-
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.pk,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=20)),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            first_url="https://first-is-on-second-event.com",
-        )
-
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.pk,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=25)),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            first_url="https://another-on-the-session.com",
-        )
-
-        # session three has no URLs
-        produce_replay_summary(
-            session_id=session_id_three,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=50),
-            distinct_id=user,
-            first_url=None,
-        )
-
-        produce_replay_summary(
-            session_id=session_id_three,
-            team_id=self.team.pk,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=10)),
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=50),
-            distinct_id=user,
-            first_url=None,
-        )
-
-        produce_replay_summary(
-            session_id=session_id_three,
-            team_id=self.team.pk,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=20)),
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=60),
-            distinct_id=user,
-            first_url=None,
-        )
-
-        # session four events are received out of order
-        produce_replay_summary(
-            session_id=session_id_four,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=20),
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=25),
-            first_url="https://on-first-received-event.com",
-        )
-        produce_replay_summary(
-            session_id=session_id_four,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=10),
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=25),
-            first_url="https://on-second-received-event-but-actually-first.com",
-        )
-
-        session_recordings, more_recordings_available, _ = self._filter_recordings_by({"no_filter": None})
-
-        assert sorted(
-            [{"session_id": r["session_id"], "first_url": r["first_url"]} for r in session_recordings],
-            key=lambda x: x["session_id"],
-        ) == sorted(
-            [
-                {
-                    "session_id": session_id_one,
-                    "first_url": "https://on-first-event.com",
-                },
-                {
-                    "session_id": session_id_two,
-                    "first_url": "https://first-is-on-second-event.com",
-                },
-                {
-                    "session_id": session_id_three,
-                    "first_url": None,
-                },
-                {
-                    "session_id": session_id_four,
-                    "first_url": "https://on-second-received-event-but-actually-first.com",
-                },
-            ],
-            # mypy unhappy about this lambda when first_url can be None 🤷️
-            key=lambda x: x["session_id"],  # type: ignore
-        )
-
-    def test_recordings_dont_leak_data_between_teams(self):
-        another_team = Team.objects.create(organization=self.organization)
-        user = "test_recordings_dont_leak_data_between_teams-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        Person.objects.create(team=another_team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_one = f"test_recordings_dont_leak_data_between_teams-1-{str(uuid4())}"
-        session_id_two = f"test_recordings_dont_leak_data_between_teams-2-{str(uuid4())}"
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=another_team.pk,
-            distinct_id=user,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=20),
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=20 * 1000 * 0.5,  # 50% of the total expected duration
-        )
-
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.pk,
-            distinct_id=user,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=self.an_hour_ago + relativedelta(seconds=20),
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=20 * 1000 * 0.5,  # 50% of the total expected duration
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by({"no_filter": None})
-
-        assert [{"session": r["session_id"], "user": r["distinct_id"]} for r in session_recordings] == [
-            {"session": session_id_two, "user": user}
-        ]
-
-    @snapshot_clickhouse_queries
-    def test_event_filter(self):
-        user = "test_event_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        session_id_one = f"test_event_filter-{str(uuid4())}"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={"$session_id": session_id_one, "$window_id": str(uuid4())},
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ]
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$autocapture",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$autocapture",
-                    }
-                ]
-            }
-        )
-        assert session_recordings == []
-
-    @snapshot_clickhouse_queries
-    def test_event_filter_has_ttl_applied_too(self):
-        user = "test_event_filter_has_ttl_applied_too-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        session_id_one = f"test_event_filter_has_ttl_applied_too-{str(uuid4())}"
-
-        # this is artificially incorrect data, the session events are within TTL
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        # but the page view event is outside TTL
-        self.create_event(
-            user,
-            self.an_hour_ago - relativedelta(days=SessionRecordingListFromFilters.SESSION_RECORDINGS_DEFAULT_LIMIT + 1),
-            properties={"$session_id": session_id_one, "$window_id": str(uuid4())},
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ]
-            }
-        )
-        assert len(session_recordings) == 0
-
-        (session_recordings, _, _) = self._filter_recordings_by({})
-        # without an event filter the recording is present, showing that the TTL was applied to the events table too
-        # we want this to limit the amount of event data we query
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-    @snapshot_clickhouse_queries
-    def test_ttl_days(self):
-        assert ttl_days(self.team) == 21
-
-        with self.is_cloud(True):
-            # Far enough in the future from `days_since_blob_ingestion` but not paid
-            with freeze_time("2023-09-01T12:00:01Z"):
-                assert ttl_days(self.team) == 30
-
-            self.team.organization.available_product_features = [
-                {"key": AvailableFeature.RECORDINGS_PLAYLISTS, "name": AvailableFeature.RECORDINGS_PLAYLISTS}
-            ]
-
-            # Far enough in the future from `days_since_blob_ingestion` but paid
-            with freeze_time("2023-12-01T12:00:01Z"):
-                assert ttl_days(self.team) == 90
-
-            # Not far enough in the future from `days_since_blob_ingestion`
-            with freeze_time("2023-09-05T12:00:01Z"):
-                assert ttl_days(self.team) == 35
-
-    @snapshot_clickhouse_queries
-    def test_listing_ignores_future_replays(self):
-        with freeze_time("2023-08-29T12:00:01Z"):
-            produce_replay_summary(team_id=self.team.id, session_id="29th Aug")
-
-        with freeze_time("2023-09-01T12:00:01Z"):
-            produce_replay_summary(team_id=self.team.id, session_id="1st-sep")
-
-        with freeze_time("2023-09-02T12:00:01Z"):
-            produce_replay_summary(team_id=self.team.id, session_id="2nd-sep")
-
-        with freeze_time("2023-09-03T12:00:01Z"):
-            produce_replay_summary(team_id=self.team.id, session_id="3rd-sep")
-
-        with freeze_time("2023-08-30T12:00:01Z"):
-            recordings = self._filter_recordings_by()
-
-            # recordings in the future don't show
-            assert [s["session_id"] for s in recordings.results] == ["29th Aug"]
-
-    @snapshot_clickhouse_queries
-    def test_filter_on_session_ids(self):
-        user = "test_session_ids-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        first_session_id = str(uuid4())
-        second_session_id = str(uuid4())
-        third_session_id = str(uuid4())
-
-        produce_replay_summary(
-            session_id=first_session_id,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(minutes=5)),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=59000,
-        )
-
-        produce_replay_summary(
-            session_id=second_session_id,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(minutes=1)),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=61000,
-        )
-
-        produce_replay_summary(
-            session_id=third_session_id,
-            team_id=self.team.pk,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(minutes=10)),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=0,
-            keypress_count=0,
-            mouse_activity_count=0,
-            active_milliseconds=0,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "session_ids": [first_session_id],
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == first_session_id
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "session_ids": [first_session_id, second_session_id],
-            }
-        )
-
-        assert sorted([s["session_id"] for s in session_recordings]) == sorted(
-            [
-                first_session_id,
-                second_session_id,
-            ]
-        )
-
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_active_sessions(
-        self,
-    ):
-        user = "test_basic_query-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_total_is_61 = f"test_basic_query_active_sessions-total-{str(uuid4())}"
-        session_id_active_is_61 = f"test_basic_query_active_sessions-active-{str(uuid4())}"
-
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={
-                "$session_id": session_id_total_is_61,
-                "$window_id": str(uuid4()),
-            },
-        )
-        produce_replay_summary(
-            session_id=session_id_total_is_61,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago.isoformat().replace("T", " "),
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=61)).isoformat().replace("T", " "),
-            distinct_id=user,
-            first_url="https://example.io/home",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=59000,
-        )
-
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={
-                "$session_id": session_id_active_is_61,
-                "$window_id": str(uuid4()),
-            },
-        )
-        produce_replay_summary(
-            session_id=session_id_active_is_61,
-            team_id=self.team.pk,
-            # can CH handle a timestamp with no T
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=59)),
-            distinct_id=user,
-            first_url="https://a-different-url.com",
-            click_count=2,
-            keypress_count=2,
-            mouse_activity_count=2,
-            active_milliseconds=61000,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "having_predicates": '[{"type":"recording","key":"duration","value":60,"operator":"gt"}]',
-            }
-        )
-
-        assert [(s["session_id"], s["duration"], s["active_seconds"]) for s in session_recordings] == [
-            (session_id_total_is_61, 61, 59.0)
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "having_predicates": '[{"type":"recording","key":"active_seconds","value":60,"operator":"gt"}]',
-            }
-        )
-
-        assert [(s["session_id"], s["duration"], s["active_seconds"]) for s in session_recordings] == [
-            (session_id_active_is_61, 59, 61.0)
-        ]
-
-    @also_test_with_materialized_columns(["$current_url", "$browser"])
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_properties(self):
-        user = "test_event_filter_with_properties-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        session_id_one = f"test_event_filter_with_properties-{str(uuid4())}"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={
-                "$browser": "Chrome",
-                "$session_id": session_id_one,
-                "$window_id": str(uuid4()),
-            },
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            event_name="a_different_event",
-            properties={
-                "$browser": "Safari",
-                "$session_id": session_id_one,
-                "$window_id": str(uuid4()),
-            },
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Chrome"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Firefox"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-        assert session_recordings == []
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "a_different_event",
-                        "type": "events",
-                        "order": 0,
-                        "name": "a_different_event",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Chrome"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-        assert len(session_recordings) == 0
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "a_different_event",
-                        "type": "events",
-                        "order": 0,
-                        "name": "a_different_event",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Safari"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-    @snapshot_clickhouse_queries
-    def test_multiple_event_filters(self):
-        session_id = f"test_multiple_event_filters-{str(uuid4())}"
-        user = "test_multiple_event_filters-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={"$session_id": session_id, "$window_id": "1", "foo": "bar"},
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={"$session_id": session_id, "$window_id": "1", "bar": "foo"},
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={"$session_id": session_id, "$window_id": "1", "bar": "foo"},
-            event_name="new-event",
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    },
-                    {
-                        "id": "new-event",
-                        "type": "events",
-                        "order": 0,
-                        "name": "new-event",
-                    },
-                ]
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    },
-                    {
-                        "id": "new-event2",
-                        "type": "events",
-                        "order": 0,
-                        "name": "new-event2",
-                    },
-                ]
-            }
-        )
-        assert session_recordings == []
-
-        # it uses hasAny instead of hasAll because of the OR filter
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    },
-                    {
-                        "id": "new-event2",
-                        "type": "events",
-                        "order": 0,
-                        "name": "new-event2",
-                    },
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 1
-
-        # two events with the same name
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "name": "$pageview",
-                        "properties": [{"key": "foo", "value": ["bar"], "operator": "exact", "type": "event"}],
-                    },
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "name": "$pageview",
-                        "properties": [{"key": "bar", "value": ["foo"], "operator": "exact", "type": "event"}],
-                    },
-                ],
-                "operand": "AND",
-            }
-        )
-        assert len(session_recordings) == 1
-
-        # two events with different names
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "name": "$pageview",
-                        "properties": [{"key": "foo", "value": ["bar"], "operator": "exact", "type": "event"}],
-                    },
-                    {
-                        "id": "new-event",
-                        "type": "events",
-                        "name": "new-event",
-                        "properties": [{"key": "foo", "value": ["bar"], "operator": "exact", "type": "event"}],
-                    },
-                ],
-                "operand": "AND",
-            }
-        )
-        assert len(session_recordings) == 0
-
-        # two events with different names
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "name": "$pageview",
-                        "properties": [{"key": "foo", "value": ["bar"], "operator": "exact", "type": "event"}],
-                    },
-                    {
-                        "id": "new-event",
-                        "type": "events",
-                        "name": "new-event",
-                        "properties": [{"key": "foo", "value": ["bar"], "operator": "exact", "type": "event"}],
-                    },
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 1
-
-    @snapshot_clickhouse_queries
-    @also_test_with_materialized_columns(["$session_id", "$browser"], person_properties=["email"])
-    @freeze_time("2023-01-04")
-    def test_action_filter(self):
-        user = "test_action_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        session_id_one = f"test_action_filter-session-one"
-        window_id = "test_action_filter-window-id"
-        action_with_properties = self.create_action(
-            "custom-event",
-            properties=[
-                {"key": "$browser", "value": "Firefox"},
-                {"key": "$session_id", "value": session_id_one},
-                {"key": "$window_id", "value": window_id},
-            ],
-        )
-        action_without_properties = self.create_action(
-            name="custom-event",
-            properties=[
-                {"key": "$session_id", "value": session_id_one},
-                {"key": "$window_id", "value": window_id},
-            ],
-        )
-
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            event_name="custom-event",
-            properties={
-                "$browser": "Chrome",
-                "$session_id": session_id_one,
-                "$window_id": window_id,
-            },
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "actions": [
-                    {
-                        "id": action_with_properties.id,
-                        "type": "actions",
-                        "order": 1,
-                        "name": "custom-event",
-                    }
-                ]
-            }
-        )
-        assert session_recordings == []
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "actions": [
-                    {
-                        "id": action_without_properties.id,
-                        "type": "actions",
-                        "order": 1,
-                        "name": "custom-event",
-                    }
-                ]
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-        # Adding properties to an action
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "actions": [
-                    {
-                        "id": action_without_properties.id,
-                        "type": "actions",
-                        "order": 1,
-                        "name": "custom-event",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Firefox"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-        assert session_recordings == []
-
-        # Adding matching properties to an action
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "actions": [
-                    {
-                        "id": action_without_properties.id,
-                        "type": "actions",
-                        "order": 1,
-                        "name": "custom-event",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Chrome"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-    def test_all_sessions_recording_object_keys_with_entity_filter(self):
-        user = "test_all_sessions_recording_object_keys_with_entity_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        session_id = f"test_all_sessions_recording_object_keys_with_entity_filter-{str(uuid4())}"
-        window_id = str(uuid4())
-
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=60)),
-            team_id=self.team.id,
-            first_url="https://recieved-out-of-order.com/second",
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={"$session_id": session_id, "$window_id": window_id},
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-            first_url="https://recieved-out-of-order.com/first",
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ]
-            }
-        )
-
-        assert session_recordings == [
-            {
-                "activity_score": 0,
-                "session_id": session_id,
-                "distinct_id": user,
-                "duration": 60,
-                "start_time": self.an_hour_ago,
-                "end_time": self.an_hour_ago + relativedelta(seconds=60),
-                "active_seconds": 0.0,
-                "click_count": 0,
-                "first_url": "https://recieved-out-of-order.com/first",
-                "inactive_seconds": 60.0,
-                "keypress_count": 0,
-                "mouse_activity_count": 0,
-                "team_id": self.team.id,
-                "console_log_count": 0,
-                "console_warn_count": 0,
-                "console_error_count": 0,
-                "ongoing": 1,
-            }
-        ]
-
-    @snapshot_clickhouse_queries
-    def test_duration_filter(self):
-        user = "test_duration_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_one = "session one is 29 seconds long"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=29)),
-            team_id=self.team.id,
-        )
-
-        session_id_two = "session two is 61 seconds long"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_two,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=61)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {"having_predicates": '[{"type":"recording","key":"duration","value":60,"operator":"gt"}]'}
-        )
-        assert [r["session_id"] for r in session_recordings] == [session_id_two]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {"having_predicates": '[{"type":"recording","key":"duration","value":60,"operator":"lt"}]'}
-        )
-        assert [r["session_id"] for r in session_recordings] == [session_id_one]
-
-    @snapshot_clickhouse_queries
-    def test_operand_or_person_filters(self):
-        user = "test_operand_or_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "test@posthog.com"})
-
-        second_user = "test_operand_or_filter-second_user"
-        Person.objects.create(team=self.team, distinct_ids=[second_user], properties={"email": "david@posthog.com"})
-
-        session_id_one = "session_id_one"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        session_id_two = "session_id_two"
-        produce_replay_summary(
-            distinct_id=second_user,
-            session_id=session_id_two,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "properties": [
-                    {
-                        "key": "email",
-                        "value": ["test@posthog.com"],
-                        "operator": "exact",
-                        "type": "person",
-                    },
-                    {
-                        "key": "email",
-                        "value": ["david@posthog.com"],
-                        "operator": "exact",
-                        "type": "person",
-                    },
-                ],
-                "operand": "AND",
-            }
-        )
-        assert len(session_recordings) == 0
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "properties": [
-                    {
-                        "key": "email",
-                        "value": ["test@posthog.com"],
-                        "operator": "exact",
-                        "type": "person",
-                    },
-                    {
-                        "key": "email",
-                        "value": ["david@posthog.com"],
-                        "operator": "exact",
-                        "type": "person",
-                    },
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 2
-        assert sorted([r["session_id"] for r in session_recordings]) == sorted([session_id_one, session_id_two])
-
-    @snapshot_clickhouse_queries
-    def test_operand_or_event_filters(self):
-        user = "test_operand_or_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "test@posthog.com"})
-
-        second_user = "test_operand_or_filter-second_user"
-        Person.objects.create(team=self.team, distinct_ids=[second_user], properties={"email": "david@posthog.com"})
-
-        session_id_one = "session_id_one"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago + relativedelta(seconds=10),
-            properties={"$session_id": session_id_one},
-        )
-
-        session_id_two = "session_id_two"
-        produce_replay_summary(
-            distinct_id=second_user,
-            session_id=session_id_two,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago + relativedelta(seconds=10),
-            event_name="custom_event",
-            properties={"$session_id": session_id_two},
-        )
-
-        session_id_three = "session_id_three"
-        produce_replay_summary(
-            distinct_id=second_user,
-            session_id=session_id_three,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    },
-                    {
-                        "id": "custom_event",
-                        "type": "events",
-                        "order": 0,
-                        "name": "custom_event",
-                    },
-                ],
-                "operand": "AND",
-            }
-        )
-        assert len(session_recordings) == 0
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    },
-                    {
-                        "id": "custom_event",
-                        "type": "events",
-                        "order": 0,
-                        "name": "custom_event",
-                    },
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 2
-        assert sorted([r["session_id"] for r in session_recordings]) == sorted([session_id_two, session_id_one])
-
-    @parameterized.expand(
-        [
-            # Case 1: Neither has WARN and message "random"
-            (
-                '[{"key": "level", "value": ["warn"], "operator": "exact", "type": "log_entry"}, {"key": "message", "value": "random", "operator": "exact", "type": "log_entry"}]',
-                "AND",
-                0,
-                [],
-            ),
-            # Case 2: AND only matches one recording
-            (
-                '[{"key": "level", "value": ["info"], "operator": "exact", "type": "log_entry"}, {"key": "message", "value": "random", "operator": "exact", "type": "log_entry"}]',
-                "AND",
-                1,
-                ["both_log_filters"],
-            ),
-            # Case 3: Only one is WARN level
-            (
-                '[{"key": "level", "value": ["warn"], "operator": "exact", "type": "log_entry"}]',
-                "AND",
-                1,
-                ["one_log_filter"],
-            ),
-            # Case 4: Only one has message "random"
-            (
-                '[{"key": "message", "value": "random", "operator": "exact", "type": "log_entry"}]',
-                "AND",
-                1,
-                ["both_log_filters"],
-            ),
-            # Case 5: OR matches both
-            (
-                '[{"key": "level", "value": ["warn"], "operator": "exact", "type": "log_entry"}, {"key": "message", "value": "random", "operator": "exact", "type": "log_entry"}]',
-                "OR",
-                2,
-                ["both_log_filters", "one_log_filter"],
-            ),
-        ]
-    )
-    @snapshot_clickhouse_queries
-    def test_operand_or_filters(
-        self,
-        console_log_filters: str,
-        operand: Literal["AND", "OR"],
-        expected_count: int,
-        expected_session_ids: list[str],
-    ) -> None:
-        user = "test_operand_or_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_with_both_log_filters = "both_log_filters"
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=session_with_both_log_filters,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_log_count=1,
-            log_messages={"info": ["random"]},
-        )
-
-        session_with_one_log_filter = "one_log_filter"
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=session_with_one_log_filter,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_warn_count=1,
-            log_messages={"warn": ["warn"]},
-        )
-
-        session_recordings, _, _ = self._filter_recordings_by(
-            {"console_log_filters": console_log_filters, "operand": operand}
-        )
-
-        assert len(session_recordings) == expected_count
-        assert sorted([rec["session_id"] for rec in session_recordings]) == sorted(expected_session_ids)
-
-    @snapshot_clickhouse_queries
-    def test_operand_or_mandatory_filters(self):
-        user = "test_operand_or_filter-user"
-        person = Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        second_user = "test_operand_or_filter-second_user"
-        second_person = Person.objects.create(team=self.team, distinct_ids=[second_user], properties={"email": "bla"})
-
-        session_id_one = "session_id_one"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-        self.create_event(
-            user,
-            self.an_hour_ago + relativedelta(seconds=10),
-            properties={"$session_id": session_id_one},
-        )
-
-        session_id_two = "session_id_two"
-        produce_replay_summary(
-            distinct_id=second_user,
-            session_id=session_id_two,
-            first_timestamp=self.an_hour_ago,
-            last_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        # person or event filter -> person matches, event matches -> returns session
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "person_uuid": str(person.uuid),
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-        # person or event filter -> person does not match, event matches -> does not return session
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "person_uuid": str(second_person.uuid),
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 0
-
-        # session_id or event filter -> person matches, event matches -> returns session
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "session_ids": [session_id_one],
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id_one
-
-        # session_id or event filter -> person does not match, event matches -> does not return session
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "session_ids": [session_id_two],
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "operand": "OR",
-            }
-        )
-        assert len(session_recordings) == 0
-
-    @snapshot_clickhouse_queries
-    def test_date_from_filter(self):
-        user = "test_date_from_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        produce_replay_summary(
-            distinct_id=user,
-            session_id="three days before base time",
-            first_timestamp=(self.an_hour_ago - relativedelta(days=3, seconds=100)),
-            last_timestamp=(self.an_hour_ago - relativedelta(days=3)),
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id="two days before base time",
-            first_timestamp=(self.an_hour_ago - relativedelta(days=2, seconds=100)),
-            last_timestamp=(self.an_hour_ago - relativedelta(days=2)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by({"date_from": self.an_hour_ago.strftime("%Y-%m-%d")})
-        assert session_recordings == []
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {"date_from": (self.an_hour_ago - relativedelta(days=2)).strftime("%Y-%m-%d")}
-        )
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == "two days before base time"
-
-    @snapshot_clickhouse_queries
-    def test_date_from_filter_cannot_search_before_ttl(self):
-        with freeze_time(self.an_hour_ago):
-            user = "test_date_from_filter_cannot_search_before_ttl-user"
-            Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-            produce_replay_summary(
-                distinct_id=user,
-                session_id="storage is past ttl",
-                first_timestamp=(self.an_hour_ago - relativedelta(days=22)),
-                # an illegally long session but it started 22 days ago
-                last_timestamp=(self.an_hour_ago - relativedelta(days=3)),
-                team_id=self.team.id,
-            )
-            produce_replay_summary(
-                distinct_id=user,
-                session_id="storage is not past ttl",
-                first_timestamp=(self.an_hour_ago - relativedelta(days=19)),
-                last_timestamp=(self.an_hour_ago - relativedelta(days=2)),
-                team_id=self.team.id,
-            )
-
-            (session_recordings, _, _) = self._filter_recordings_by(
-                {"date_from": (self.an_hour_ago - relativedelta(days=20)).strftime("%Y-%m-%d")}
-            )
-            assert len(session_recordings) == 1
-            assert session_recordings[0]["session_id"] == "storage is not past ttl"
-
-            (session_recordings, _, _) = self._filter_recordings_by(
-                {"date_from": (self.an_hour_ago - relativedelta(days=21)).strftime("%Y-%m-%d")}
-            )
-            assert len(session_recordings) == 1
-            assert session_recordings[0]["session_id"] == "storage is not past ttl"
-
-            (session_recordings, _, _) = self._filter_recordings_by(
-                {"date_from": (self.an_hour_ago - relativedelta(days=22)).strftime("%Y-%m-%d")}
-            )
-            assert len(session_recordings) == 1
-            assert session_recordings[0]["session_id"] == "storage is not past ttl"
-
-    @snapshot_clickhouse_queries
-    def test_date_to_filter(self):
-        user = "test_date_to_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        produce_replay_summary(
-            distinct_id=user,
-            session_id="three days before base time",
-            first_timestamp=(self.an_hour_ago - relativedelta(days=3, seconds=100)),
-            last_timestamp=(self.an_hour_ago - relativedelta(days=3)),
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id="two days before base time",
-            first_timestamp=(self.an_hour_ago - relativedelta(days=2, seconds=100)),
-            last_timestamp=(self.an_hour_ago - relativedelta(days=2)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {"date_to": (self.an_hour_ago - relativedelta(days=4)).strftime("%Y-%m-%d")}
-        )
-        assert session_recordings == []
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {"date_to": (self.an_hour_ago - relativedelta(days=3)).strftime("%Y-%m-%d")}
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == "three days before base time"
-
-    def test_recording_that_spans_time_bounds(self):
-        user = "test_recording_that_spans_time_bounds-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        day_line = datetime(2021, 11, 5)
-        session_id = f"session-one-{user}"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=(day_line - relativedelta(hours=3)),
-            last_timestamp=(day_line + relativedelta(hours=3)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "date_to": day_line.strftime("%Y-%m-%d"),
-                "date_from": (day_line - relativedelta(days=10)).strftime("%Y-%m-%d"),
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id
-        assert session_recordings[0]["duration"] == 6 * 60 * 60
-
-    @snapshot_clickhouse_queries
-    def test_person_id_filter(self):
-        three_user_ids = [str(uuid4()) for _ in range(3)]
-        session_id_one = f"test_person_id_filter-{str(uuid4())}"
-        session_id_two = f"test_person_id_filter-{str(uuid4())}"
-        p = Person.objects.create(
-            team=self.team,
-            distinct_ids=[three_user_ids[0], three_user_ids[1]],
-            properties={"email": "bla"},
-        )
-        produce_replay_summary(
-            distinct_id=three_user_ids[0],
-            session_id=session_id_one,
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=three_user_ids[1],
-            session_id=session_id_two,
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=three_user_ids[2],
-            session_id=str(uuid4()),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by({"person_uuid": str(p.uuid)})
-        assert sorted([r["session_id"] for r in session_recordings]) == sorted([session_id_two, session_id_one])
-
-    @snapshot_clickhouse_queries
-    def test_all_filters_at_once(self):
-        three_user_ids = [str(uuid4()) for _ in range(3)]
-        target_session_id = f"test_all_filters_at_once-{str(uuid4())}"
-
-        p = Person.objects.create(
-            team=self.team,
-            distinct_ids=[three_user_ids[0], three_user_ids[1]],
-            properties={"email": "bla"},
-        )
-        custom_event_action = self.create_action(name="custom-event")
-
-        produce_replay_summary(
-            distinct_id=three_user_ids[0],
-            session_id=target_session_id,
-            first_timestamp=(self.an_hour_ago - relativedelta(days=3)),
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            # does not match because of user distinct id
-            distinct_id=three_user_ids[2],
-            session_id=target_session_id,
-            first_timestamp=(self.an_hour_ago - relativedelta(days=3)),
-            team_id=self.team.id,
-        )
-        self.create_event(
-            three_user_ids[0],
-            self.an_hour_ago - relativedelta(days=3),
-            properties={"$session_id": target_session_id},
-        )
-        self.create_event(
-            three_user_ids[0],
-            self.an_hour_ago - relativedelta(days=3),
-            event_name="custom-event",
-            properties={"$browser": "Chrome", "$session_id": target_session_id},
-        )
-        produce_replay_summary(
-            distinct_id=three_user_ids[1],
-            session_id=target_session_id,
-            first_timestamp=(self.an_hour_ago - relativedelta(days=3) + relativedelta(hours=6)),
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=three_user_ids[1],
-            # does not match because of session id
-            session_id=str(uuid4()),
-            first_timestamp=(self.an_hour_ago - relativedelta(days=3) + relativedelta(hours=6)),
-            team_id=self.team.id,
-        )
-
-        flush_persons_and_events()
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "person_uuid": str(p.uuid),
-                "date_to": (self.an_hour_ago + relativedelta(days=3)).strftime("%Y-%m-%d"),
-                "date_from": (self.an_hour_ago - relativedelta(days=10)).strftime("%Y-%m-%d"),
-                "session_recording_duration": '{"type":"recording","key":"duration","value":60,"operator":"gt"}',
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "actions": [
-                    {
-                        "id": custom_event_action.id,
-                        "type": "actions",
-                        "order": 1,
-                        "name": "custom-event",
-                    }
-                ],
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == target_session_id
-
-    def test_teams_dont_leak_event_filter(self):
-        user = "test_teams_dont_leak_event_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-        another_team = Team.objects.create(organization=self.organization)
-
-        session_id = f"test_teams_dont_leak_event_filter-{str(uuid4())}"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(1, self.an_hour_ago + relativedelta(seconds=15), team=another_team)
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ]
-            }
-        )
-        assert session_recordings == []
-
-    @snapshot_clickhouse_queries
-    @also_test_with_materialized_columns(person_properties=["email"])
-    def test_filter_with_person_properties_exact(self):
-        session_id_one, session_id_two = self._two_sessions_two_persons(
-            "test_filter_with_person_properties_exact",
-            session_one_person_properties={"email": "bla@gmail.com"},
-            session_two_person_properties={"email": "bla2@hotmail.com"},
-        )
-
-        query_results: SessionRecordingQueryResult = self._filter_recordings_by(
-            {
-                "properties": [
-                    {
-                        "key": "email",
-                        "value": ["bla@gmail.com"],
-                        "operator": "exact",
-                        "type": "person",
-                    }
-                ]
-            }
-        )
-
-        assert [x["session_id"] for x in query_results.results] == [session_id_one]
-
-    @snapshot_clickhouse_queries
-    @also_test_with_materialized_columns(person_properties=["email"])
-    def test_filter_with_person_properties_not_contains(self):
-        session_id_one, session_id_two = self._two_sessions_two_persons(
-            "test_filter_with_person_properties_not_contains",
-            session_one_person_properties={"email": "bla@gmail.com"},
-            session_two_person_properties={"email": "bla2@hotmail.com"},
-        )
-
-        query_results: SessionRecordingQueryResult = self._filter_recordings_by(
-            {"properties": [{"key": "email", "value": "gmail.com", "operator": "not_icontains", "type": "person"}]}
-        )
-
-        assert [x["session_id"] for x in query_results.results] == [session_id_two]
-
-    def _two_sessions_two_persons(
-        self, label: str, session_one_person_properties: dict, session_two_person_properties: dict
-    ) -> tuple[str, str]:
-        sessions = []
-
-        for i in range(2):
-            user = f"{label}-user-{i}"
-            session = f"{label}-session-{i}"
-            sessions.append(session)
-
-            Person.objects.create(
-                team=self.team,
-                distinct_ids=[user],
-                properties=session_one_person_properties if i == 0 else session_two_person_properties,
-            )
-
-            produce_replay_summary(
-                distinct_id=user,
-                session_id=session,
-                first_timestamp=self.an_hour_ago,
-                team_id=self.team.id,
-            )
-            produce_replay_summary(
-                distinct_id=user,
-                session_id=session,
-                first_timestamp=(self.an_hour_ago + relativedelta(seconds=30)),
-                team_id=self.team.id,
-            )
-
-        return sessions[0], sessions[1]
-
-    @snapshot_clickhouse_queries
-    @also_test_with_materialized_columns(person_properties=["$some_prop"])
-    def test_filter_with_cohort_properties(self):
-        with self.settings(USE_PRECALCULATED_CH_COHORT_PEOPLE=True):
-            with freeze_time("2021-08-21T20:00:00.000Z"):
-                user_one = "test_filter_with_cohort_properties-user"
-                user_two = "test_filter_with_cohort_properties-user2"
-                session_id_one = f"test_filter_with_cohort_properties-1-{str(uuid4())}"
-                session_id_two = f"test_filter_with_cohort_properties-2-{str(uuid4())}"
-
-                Person.objects.create(team=self.team, distinct_ids=[user_one], properties={"email": "bla"})
-                Person.objects.create(
-                    team=self.team,
-                    distinct_ids=[user_two],
-                    properties={"email": "bla2", "$some_prop": "some_val"},
-                )
-                cohort = Cohort.objects.create(
-                    team=self.team,
-                    name="cohort1",
-                    groups=[
-                        {
-                            "properties": [
-                                {
-                                    "key": "$some_prop",
-                                    "value": "some_val",
-                                    "type": "person",
-                                }
-                            ]
-                        }
-                    ],
-                )
-                cohort.calculate_people_ch(pending_version=0)
-
-                produce_replay_summary(
-                    distinct_id=user_one,
-                    session_id=session_id_one,
-                    first_timestamp=self.an_hour_ago,
-                    team_id=self.team.id,
-                )
-                # self.create_event(user_one, self.base_time, team=self.team)
-                produce_replay_summary(
-                    distinct_id=user_one,
-                    session_id=session_id_one,
-                    first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-                    team_id=self.team.id,
-                )
-                produce_replay_summary(
-                    distinct_id=user_two,
-                    session_id=session_id_two,
-                    first_timestamp=self.an_hour_ago,
-                    team_id=self.team.id,
-                )
-                # self.create_event(user_two, self.base_time, team=self.team)
-                produce_replay_summary(
-                    distinct_id=user_two,
-                    session_id=session_id_two,
-                    first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-                    team_id=self.team.id,
-                )
-
-                (session_recordings, _, _) = self._filter_recordings_by(
-                    {
-                        "properties": [
-                            {
-                                "key": "id",
-                                "value": cohort.pk,
-                                "operator": "in",
-                                "type": "cohort",
-                            }
-                        ]
-                    }
-                )
-
-                assert [x["session_id"] for x in session_recordings] == [session_id_two]
-
-    @snapshot_clickhouse_queries
-    @also_test_with_materialized_columns(person_properties=["$some_prop"])
-    def test_filter_with_static_and_dynamic_cohort_properties(self):
-        with self.settings(USE_PRECALCULATED_CH_COHORT_PEOPLE=True):
-            with freeze_time("2021-08-21T20:00:00.000Z"):
-                user_one = "test_filter_with_cohort_properties-user-in-static-cohort"
-                user_two = "test_filter_with_cohort_properties-user2-in-dynamic-cohort"
-                user_three = "test_filter_with_cohort_properties-user3-in-both-cohort"
-
-                session_id_one = (
-                    f"in-static-cohort-test_filter_with_static_and_dynamic_cohort_properties-1-{str(uuid4())}"
-                )
-                session_id_two = (
-                    f"in-dynamic-cohort-test_filter_with_static_and_dynamic_cohort_properties-2-{str(uuid4())}"
-                )
-                session_id_three = (
-                    f"in-both-cohort-test_filter_with_static_and_dynamic_cohort_properties-3-{str(uuid4())}"
-                )
-
-                Person.objects.create(team=self.team, distinct_ids=[user_one], properties={"email": "in@static.cohort"})
-                Person.objects.create(
-                    team=self.team,
-                    distinct_ids=[user_two],
-                    properties={"email": "in@dynamic.cohort", "$some_prop": "some_val"},
-                )
-                Person.objects.create(
-                    team=self.team,
-                    distinct_ids=[user_three],
-                    properties={"email": "in@both.cohorts", "$some_prop": "some_val"},
-                )
-
-                dynamic_cohort = Cohort.objects.create(
-                    team=self.team,
-                    name="cohort1",
-                    groups=[
-                        {
-                            "properties": [
-                                {
-                                    "key": "$some_prop",
-                                    "value": "some_val",
-                                    "type": "person",
-                                }
-                            ]
-                        }
-                    ],
-                )
-
-                static_cohort = Cohort.objects.create(team=self.team, name="a static cohort", groups=[], is_static=True)
-                static_cohort.insert_users_by_list([user_one, user_three])
-
-                dynamic_cohort.calculate_people_ch(pending_version=0)
-                static_cohort.calculate_people_ch(pending_version=0)
-
-                replay_summaries = [
-                    (user_one, session_id_one),
-                    (user_two, session_id_two),
-                    (user_three, session_id_three),
-                ]
-                for distinct_id, session_id in replay_summaries:
-                    produce_replay_summary(
-                        distinct_id=distinct_id,
-                        session_id=session_id,
-                        first_timestamp=self.an_hour_ago,
-                        team_id=self.team.id,
-                    )
-                    produce_replay_summary(
-                        distinct_id=distinct_id,
-                        session_id=session_id,
-                        first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-                        team_id=self.team.id,
-                    )
-
-                (session_recordings, _, _) = self._filter_recordings_by(
-                    {
-                        "properties": [
-                            {
-                                "key": "id",
-                                "value": static_cohort.pk,
-                                "operator": "in",
-                                "type": "cohort",
-                            },
-                        ]
-                    }
-                )
-
-                assert sorted([x["session_id"] for x in session_recordings]) == sorted(
-                    [session_id_one, session_id_three]
-                )
-
-                (session_recordings, _, _) = self._filter_recordings_by(
-                    {
-                        "properties": [
-                            {
-                                "key": "id",
-                                "value": dynamic_cohort.pk,
-                                "operator": "in",
-                                "type": "cohort",
-                            },
-                        ]
-                    }
-                )
-
-                assert sorted([x["session_id"] for x in session_recordings]) == sorted(
-                    [session_id_two, session_id_three]
-                )
-
-                (session_recordings, _, _) = self._filter_recordings_by(
-                    {
-                        "properties": [
-                            {
-                                "key": "id",
-                                "value": dynamic_cohort.pk,
-                                "operator": "in",
-                                "type": "cohort",
-                            },
-                            {
-                                "key": "id",
-                                "value": static_cohort.pk,
-                                "operator": "in",
-                                "type": "cohort",
-                            },
-                        ]
-                    }
-                )
-
-                assert sorted([x["session_id"] for x in session_recordings]) == [session_id_three]
-
-    @snapshot_clickhouse_queries
-    @also_test_with_materialized_columns(person_properties=["$some_prop"])
-    def test_filter_with_events_and_cohorts(self):
-        with self.settings(USE_PRECALCULATED_CH_COHORT_PEOPLE=True):
-            with freeze_time("2021-08-21T20:00:00.000Z"):
-                user_one = "test_filter_with_events_and_cohorts-user"
-                user_two = "test_filter_with_events_and_cohorts-user2"
-                session_id_one = f"test_filter_with_events_and_cohorts-1-{str(uuid4())}"
-                session_id_two = f"test_filter_with_events_and_cohorts-2-{str(uuid4())}"
-
-                Person.objects.create(team=self.team, distinct_ids=[user_one], properties={"email": "bla"})
-                Person.objects.create(
-                    team=self.team,
-                    distinct_ids=[user_two],
-                    properties={"email": "bla2", "$some_prop": "some_val"},
-                )
-                cohort = Cohort.objects.create(
-                    team=self.team,
-                    name="cohort1",
-                    groups=[
-                        {
-                            "properties": [
-                                {
-                                    "key": "$some_prop",
-                                    "value": "some_val",
-                                    "type": "person",
-                                }
-                            ]
-                        }
-                    ],
-                )
-                cohort.calculate_people_ch(pending_version=0)
-
-                produce_replay_summary(
-                    distinct_id=user_one,
-                    session_id=session_id_one,
-                    first_timestamp=self.an_hour_ago,
-                    team_id=self.team.id,
-                )
-                self.create_event(
-                    user_one,
-                    self.an_hour_ago,
-                    team=self.team,
-                    event_name="custom_event",
-                    properties={"$session_id": session_id_one},
-                )
-                produce_replay_summary(
-                    distinct_id=user_one,
-                    session_id=session_id_one,
-                    first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-                    team_id=self.team.id,
-                )
-                produce_replay_summary(
-                    distinct_id=user_two,
-                    session_id=session_id_two,
-                    first_timestamp=self.an_hour_ago,
-                    team_id=self.team.id,
-                )
-                self.create_event(
-                    user_two,
-                    self.an_hour_ago,
-                    team=self.team,
-                    event_name="custom_event",
-                    properties={"$session_id": session_id_two},
-                )
-                produce_replay_summary(
-                    distinct_id=user_two,
-                    session_id=session_id_two,
-                    first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-                    team_id=self.team.id,
-                )
-
-                (session_recordings, _, _) = self._filter_recordings_by(
-                    {
-                        # has to be in the cohort and pageview has to be in the events
-                        # test data has one user in the cohort but no pageviews
-                        "properties": [
-                            {
-                                "key": "id",
-                                "value": cohort.pk,
-                                "operator": "in",
-                                "type": "cohort",
-                            }
-                        ],
-                        "events": [
-                            {
-                                "id": "$pageview",
-                                "type": "events",
-                                "order": 0,
-                                "name": "$pageview",
-                            }
-                        ],
-                    }
-                )
-
-                assert len(session_recordings) == 0
-
-                (session_recordings, _, _) = self._filter_recordings_by(
-                    {
-                        "properties": [
-                            {
-                                "key": "id",
-                                "value": cohort.pk,
-                                "operator": "in",
-                                "type": "cohort",
-                            }
-                        ],
-                        "events": [
-                            {
-                                "id": "custom_event",
-                                "type": "events",
-                                "order": 0,
-                                "name": "custom_event",
-                            }
-                        ],
-                    }
-                )
-
-                assert [x["session_id"] for x in session_recordings] == [session_id_two]
-
-    @snapshot_clickhouse_queries
-    @also_test_with_materialized_columns(["$current_url"])
-    def test_event_filter_with_matching_on_session_id(self):
-        user_distinct_id = "test_event_filter_with_matching_on_session_id-user"
-        Person.objects.create(team=self.team, distinct_ids=[user_distinct_id], properties={"email": "bla"})
-        session_id = f"test_event_filter_with_matching_on_session_id-1-{str(uuid4())}"
-
-        self.create_event(
-            user_distinct_id,
-            self.an_hour_ago,
-            event_name="$pageview",
-            properties={"$session_id": session_id},
-        )
-        self.create_event(
-            user_distinct_id,
-            self.an_hour_ago,
-            event_name="$autocapture",
-            properties={"$session_id": str(uuid4())},
-        )
-
-        produce_replay_summary(
-            distinct_id=user_distinct_id,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=user_distinct_id,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ]
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$autocapture",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$autocapture",
-                    }
-                ]
-            }
-        )
-        assert session_recordings == []
-
-    @also_test_with_materialized_columns(event_properties=["$current_url", "$browser"], person_properties=["email"])
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_hogql_properties(self):
-        user = "test_event_filter_with_hogql_properties-user"
-
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id = f"test_event_filter_with_hogql_properties-1-{str(uuid4())}"
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={
-                "$browser": "Chrome",
-                "$session_id": session_id,
-                "$window_id": str(uuid4()),
-            },
-        )
-
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                        "properties": [
-                            {"key": "properties.$browser == 'Chrome'", "type": "hogql"},
-                        ],
-                    }
-                ]
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                        "properties": [{"key": "properties.$browser == 'Firefox'", "type": "hogql"}],
-                    }
-                ]
-            }
-        )
-
-        assert session_recordings == []
-
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_hogql_person_properties(self):
-        user = "test_event_filter_with_hogql_properties-user"
-
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id = f"test_event_filter_with_hogql_properties-1-{str(uuid4())}"
-        self.create_event(
-            user,
-            self.an_hour_ago,
-            properties={
-                "$browser": "Chrome",
-                "$session_id": session_id,
-                "$window_id": str(uuid4()),
-            },
-        )
-
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                        "properties": [
-                            {
-                                "key": "person.properties.email == 'bla'",
-                                "type": "hogql",
-                            },
-                        ],
-                    }
-                ]
-            }
-        )
-
-        assert len(session_recordings) == 1
-        assert session_recordings[0]["session_id"] == session_id
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                        "properties": [
-                            {
-                                "key": "person.properties.email == 'something else'",
-                                "type": "hogql",
-                            },
-                        ],
-                    }
-                ]
-            }
-        )
-
-        assert session_recordings == []
-
-    @also_test_with_materialized_columns(["$current_url", "$browser"])
-    @snapshot_clickhouse_queries
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    def test_any_event_filter_with_properties(self):
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-
-        page_view_session_id = f"pageview-session-{str(uuid4())}"
-        my_custom_event_session_id = f"my-custom-event-session-{str(uuid4())}"
-        non_matching__event_session_id = f"non-matching-event-session-{str(uuid4())}"
-
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$browser": "Chrome",
-                "$session_id": page_view_session_id,
-                "$window_id": "1",
-            },
-            event_name="$pageview",
-        )
-
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$browser": "Chrome",
-                "$session_id": my_custom_event_session_id,
-                "$window_id": "1",
-            },
-            event_name="my-custom-event",
-        )
-
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$browser": "Safari",
-                "$session_id": non_matching__event_session_id,
-                "$window_id": "1",
-            },
-            event_name="my-non-matching-event",
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=page_view_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=my_custom_event_session_id,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=non_matching__event_session_id,
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        # an id of null means "match any event"
-                        "id": None,
-                        "type": "events",
-                        "order": 0,
-                        "name": "All events",
-                        "properties": [],
-                    }
-                ]
-            }
-        )
-
-        assert sorted(
-            [sr["session_id"] for sr in session_recordings],
-        ) == [
-            my_custom_event_session_id,
-            non_matching__event_session_id,
-            page_view_session_id,
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        # an id of null means "match any event"
-                        "id": None,
-                        "type": "events",
-                        "order": 0,
-                        "name": "All events",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Chrome"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-
-        assert sorted(
-            [sr["session_id"] for sr in session_recordings],
-        ) == [
-            my_custom_event_session_id,
-            page_view_session_id,
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": None,
-                        "type": "events",
-                        "order": 0,
-                        "name": "All events",
-                        "properties": [
-                            {
-                                "key": "$browser",
-                                "value": ["Firefox"],
-                                "operator": "exact",
-                                "type": "event",
-                            }
-                        ],
-                    }
-                ]
-            }
-        )
-        assert session_recordings == []
-
-    @snapshot_clickhouse_queries
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    def test_filter_for_recordings_with_console_logs(self):
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-
-        with_logs_session_id = f"with-logs-session-{str(uuid4())}"
-        without_logs_session_id = f"no-logs-session-{str(uuid4())}"
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=with_logs_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_log_count=4,
-            log_messages={
-                "info": [
-                    "info",
-                    "info",
-                    "info",
-                ],
-            },
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=without_logs_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-
-        # (session_recordings, _, _) = self._filter_recordings_by({"console_logs": ["info"]})
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["info"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-
-        actual = sorted(
-            [(sr["session_id"], sr["console_log_count"]) for sr in session_recordings],
-            key=lambda x: x[0],
-        )
-
-        assert actual == [
-            (with_logs_session_id, 4),
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["warn"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-        assert session_recordings == []
-
-    @snapshot_clickhouse_queries
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    def test_filter_for_recordings_with_console_warns(self):
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-
-        with_logs_session_id = f"with-logs-session-{str(uuid4())}"
-        without_logs_session_id = f"no-logs-session-{str(uuid4())}"
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=with_logs_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_warn_count=4,
-            log_messages={
-                "warn": [
-                    "warn",
-                    "warn",
-                    "warn",
-                    "warn",
-                ],
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=without_logs_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["warn"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-
-        assert sorted(
-            [(sr["session_id"], sr["console_warn_count"]) for sr in session_recordings],
-            key=lambda x: x[0],
-        ) == [
-            (with_logs_session_id, 4),
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["info"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-
-        assert session_recordings == []
-
-    @snapshot_clickhouse_queries
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    def test_filter_for_recordings_with_console_errors(self):
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-
-        with_logs_session_id = f"with-logs-session-{str(uuid4())}"
-        without_logs_session_id = f"no-logs-session-{str(uuid4())}"
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=with_logs_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_error_count=4,
-            log_messages={
-                "error": [
-                    "error",
-                    "error",
-                    "error",
-                    "error",
-                ],
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=without_logs_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["error"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-
-        assert sorted(
-            [(sr["session_id"], sr["console_error_count"]) for sr in session_recordings],
-            key=lambda x: x[0],
-        ) == [
-            (with_logs_session_id, 4),
-        ]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["info"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-
-        assert session_recordings == []
-
-    @snapshot_clickhouse_queries
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    def test_filter_for_recordings_with_mixed_console_counts(self):
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-
-        with_logs_session_id = f"with-logs-session-{str(uuid4())}"
-        with_warns_session_id = f"with-warns-session-{str(uuid4())}"
-        with_errors_session_id = f"with-errors-session-{str(uuid4())}"
-        with_two_session_id = f"with-two-session-{str(uuid4())}"
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=with_logs_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_log_count=4,
-            log_messages={
-                "info": [
-                    "info",
-                    "info",
-                    "info",
-                    "info",
-                ],
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=with_warns_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_warn_count=4,
-            log_messages={
-                "warn": [
-                    "warn",
-                    "warn",
-                    "warn",
-                    "warn",
-                ],
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=with_errors_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_error_count=4,
-            log_messages={
-                "error": [
-                    "error",
-                    "error",
-                    "error",
-                    "error",
-                ],
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=with_two_session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_error_count=4,
-            console_log_count=3,
-            log_messages={
-                "error": [
-                    "error",
-                    "error",
-                    "error",
-                    "error",
-                ],
-                "info": [
-                    "info",
-                    "info",
-                    "info",
-                ],
-            },
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["warn", "error"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-
-        assert sorted([sr["session_id"] for sr in session_recordings]) == sorted(
-            [
-                with_errors_session_id,
-                with_two_session_id,
-                with_warns_session_id,
-            ]
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "console_log_filters": '[{"key": "level", "value": ["info"], "operator": "exact", "type": "log_entry"}]',
-                "operand": "AND",
-            }
-        )
-
-        assert sorted([sr["session_id"] for sr in session_recordings]) == sorted(
-            [
-                with_two_session_id,
-                with_logs_session_id,
-            ]
-        )
-
-    @parameterized.expand(
-        [
-            # Case 1: OR operand, message 4 matches in warn and error
-            (
-                '[{"key": "level", "value": ["warn", "error"], "operator": "exact", "type": "log_entry"}, {"key": "message", "value": "message 4", "operator": "icontains", "type": "log_entry"}]',
-                "OR",
-                ["with-errors-session", "with-two-session", "with-warns-session", "with-logs-session"],
-            ),
-            # Case 2: AND operand, message 5 matches only in warn
-            (
-                '[{"key": "level", "value": ["warn", "error"], "operator": "exact", "type": "log_entry"}, {"key": "message", "value": "message 5", "operator": "icontains", "type": "log_entry"}]',
-                "AND",
-                ["with-warns-session"],
-            ),
-            # Case 3: AND operand, message 5 does not match log level "info"
-            (
-                '[{"key": "level", "value": ["info"], "operator": "exact", "type": "log_entry"}, {"key": "message", "value": "message 5", "operator": "icontains", "type": "log_entry"}]',
-                "AND",
-                [],
-            ),
-        ]
-    )
-    @snapshot_clickhouse_queries
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    def test_filter_for_recordings_by_console_text(
-        self,
-        console_log_filters: str,
-        operand: Literal["AND", "OR"],
-        expected_session_ids: list[str],
-    ) -> None:
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-
-        # Create sessions
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="with-logs-session",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_log_count=4,
-            log_messages={
-                "info": [
-                    "log message 1",
-                    "log message 2",
-                    "log message 3",
-                    "log message 4",
-                ]
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="with-warns-session",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_warn_count=5,
-            log_messages={
-                "warn": [
-                    "warn message 1",
-                    "warn message 2",
-                    "warn message 3",
-                    "warn message 4",
-                    "warn message 5",
-                ]
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="with-errors-session",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_error_count=4,
-            log_messages={
-                "error": [
-                    "error message 1",
-                    "error message 2",
-                    "error message 3",
-                    "error message 4",
-                ]
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="with-two-session",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_error_count=4,
-            console_log_count=3,
-            log_messages={
-                "error": [
-                    "error message 1",
-                    "error message 2",
-                    "error message 3",
-                    "error message 4",
-                ],
-                "info": ["log message 1", "log message 2", "log message 3"],
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="with-no-matches-session",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            console_error_count=4,
-            console_log_count=3,
-            log_messages={
-                "info": ["log message 1", "log message 2", "log message 3"],
-            },
-        )
-
-        # Perform the filtering and validate results
-        session_recordings, _, _ = self._filter_recordings_by(
-            {"console_log_filters": console_log_filters, "operand": operand}
-        )
-
-        assert sorted([sr["session_id"] for sr in session_recordings]) == sorted(expected_session_ids)
-
-    @snapshot_clickhouse_queries
-    def test_filter_for_recordings_by_snapshot_source(self):
-        user = "test_duration_filter-user"
-        Person.objects.create(team=self.team, distinct_ids=[user], properties={"email": "bla"})
-
-        session_id_one = "session one id"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_one,
-            team_id=self.team.id,
-            snapshot_source="web",
-        )
-
-        session_id_two = "session two id"
-        produce_replay_summary(
-            distinct_id=user,
-            session_id=session_id_two,
-            team_id=self.team.id,
-            snapshot_source="mobile",
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "having_predicates": '[{"key": "snapshot_source", "value": ["web"], "operator": "exact", "type": "recording"}]'
-            }
-        )
-        assert [r["session_id"] for r in session_recordings] == [session_id_one]
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "having_predicates": '[{"key": "snapshot_source", "value": ["mobile"], "operator": "exact", "type": "recording"}]'
-            }
-        )
-        assert [r["session_id"] for r in session_recordings] == [session_id_two]
-
-    @also_test_with_materialized_columns(
-        event_properties=["is_internal_user"],
-        person_properties=["email"],
-        verify_no_jsonextract=False,
-    )
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_test_accounts_excluded(self):
-        self.team.test_account_filters = [
-            {
-                "key": "email",
-                "value": "@posthog.com",
-                "operator": "not_icontains",
-                "type": "person",
-            },
-            {
-                "key": "is_internal_user",
-                "value": ["false"],
-                "operator": "exact",
-                "type": "event",
-            },
-            {"key": "properties.$browser == 'Chrome'", "type": "hogql"},
-        ]
-        self.team.save()
-
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "1",
-                "$window_id": "1",
-                "is_internal_user": "true",
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": True,
-            }
-        )
-        self.assertEqual(len(session_recordings), 0)
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": False,
-            }
-        )
-        self.assertEqual(len(session_recordings), 1)
-
-    @also_test_with_materialized_columns(
-        event_properties=["$browser"],
-        person_properties=["email"],
-        verify_no_jsonextract=False,
-    )
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_hogql_event_properties_test_accounts_excluded(self):
-        self.team.test_account_filters = [
-            {"key": "properties.$browser == 'Chrome'", "type": "hogql"},
-        ]
-        self.team.save()
-
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        Person.objects.create(
-            team=self.team,
-            distinct_ids=["user2"],
-            properties={"email": "not-the-other-one"},
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={"$session_id": "1", "$window_id": "1", "$browser": "Chrome"},
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        produce_replay_summary(
-            distinct_id="user2",
-            session_id="2",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user2",
-            self.an_hour_ago,
-            properties={"$session_id": "2", "$window_id": "1", "$browser": "Firefox"},
-        )
-
-        # there are 2 pageviews
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # pageview that matches the hogql test_accounts filter
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": False,
-            }
-        )
-        self.assertEqual(len(session_recordings), 2)
-
-        self.team.test_account_filters = [
-            {"key": "person.properties.email == 'bla'", "type": "hogql"},
-        ]
-        self.team.save()
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # only 1 pageview that matches the hogql test_accounts filter
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": True,
-            }
-        )
-        self.assertEqual(len(session_recordings), 1)
-
-        self.team.test_account_filters = [
-            {"key": "properties.$browser == 'Chrome'", "type": "hogql"},
-            {"key": "person.properties.email == 'bla'", "type": "hogql"},
-        ]
-        self.team.save()
-
-        # one user sessions matches the person + event test_account filter
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "filter_test_accounts": True,
-            }
-        )
-        self.assertEqual(len(session_recordings), 1)
-
-    # TRICKY: we had to disable use of materialized columns for part of the query generation
-    # due to RAM usage issues on the EU cluster
-    @also_test_with_materialized_columns(event_properties=["is_internal_user"], verify_no_jsonextract=False)
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_top_level_event_property_test_account_filter(self):
-        """
-        This is a regression test. A user with an $ip test account filter
-        reported the filtering wasn't working.
-
-        The filter wasn't triggering the "should join events check", and so we didn't apply the filter at all
-        """
-        self.team.test_account_filters = [
-            {
-                "key": "is_internal_user",
-                "value": ["false"],
-                "operator": "exact",
-                "type": "event",
-            },
-        ]
-        self.team.save()
-
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        Person.objects.create(
-            team=self.team,
-            distinct_ids=["user2"],
-            properties={"email": "not-the-other-one"},
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "1",
-                "$window_id": "1",
-                "is_internal_user": False,
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        produce_replay_summary(
-            distinct_id="user2",
-            session_id="2",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user2",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "2",
-                "$window_id": "1",
-                "is_internal_user": True,
-            },
-        )
-
-        # there are 2 pageviews
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # pageview that matches the hogql test_accounts filter
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": False,
-            }
-        )
-        self.assertEqual(len(session_recordings), 2)
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # only 1 pageview that matches the test_accounts filter
-                "filter_test_accounts": True,
-            }
-        )
-        self.assertEqual(len(session_recordings), 1)
-
-    # TRICKY: we had to disable use of materialized columns for part of the query generation
-    # due to RAM usage issues on the EU cluster
-    @also_test_with_materialized_columns(event_properties=["is_internal_user"], verify_no_jsonextract=True)
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_top_level_event_property_test_account_filter_allowing_denormalized_props(self):
-        """
-        This is a duplicate of the test test_top_level_event_property_test_account_filter
-        but with denormalized props allowed
-        """
-
-        with self.settings(ALLOW_DENORMALIZED_PROPS_IN_LISTING=True):
-            self.team.test_account_filters = [
-                {
-                    "key": "is_internal_user",
-                    "value": ["false"],
-                    "operator": "exact",
-                    "type": "event",
-                },
-            ]
-            self.team.save()
-
-            Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-            Person.objects.create(
-                team=self.team,
-                distinct_ids=["user2"],
-                properties={"email": "not-the-other-one"},
-            )
-
-            produce_replay_summary(
-                distinct_id="user",
-                session_id="1",
-                first_timestamp=self.an_hour_ago,
-                team_id=self.team.id,
-            )
-            self.create_event(
-                "user",
-                self.an_hour_ago,
-                properties={
-                    "$session_id": "1",
-                    "$window_id": "1",
-                    "is_internal_user": False,
-                },
-            )
-            produce_replay_summary(
-                distinct_id="user",
-                session_id="1",
-                first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-                team_id=self.team.id,
-            )
-
-            produce_replay_summary(
-                distinct_id="user2",
-                session_id="2",
-                first_timestamp=self.an_hour_ago,
-                team_id=self.team.id,
-            )
-            self.create_event(
-                "user2",
-                self.an_hour_ago,
-                properties={
-                    "$session_id": "2",
-                    "$window_id": "1",
-                    "is_internal_user": True,
-                },
-            )
-
-            # there are 2 pageviews
-            (session_recordings, _, _) = self._filter_recordings_by(
-                {
-                    # pageview that matches the hogql test_accounts filter
-                    "events": [
-                        {
-                            "id": "$pageview",
-                            "type": "events",
-                            "order": 0,
-                            "name": "$pageview",
-                        }
-                    ],
-                    "filter_test_accounts": False,
-                }
-            )
-            self.assertEqual(len(session_recordings), 2)
-
-            (session_recordings, _, _) = self._filter_recordings_by(
-                {
-                    # only 1 pageview that matches the test_accounts filter
-                    "filter_test_accounts": True,
-                }
-            )
-            self.assertEqual(len(session_recordings), 1)
-
-    @also_test_with_materialized_columns(event_properties=["is_internal_user"])
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_top_level_hogql_event_property_test_account_filter(self):
-        """
-        This is a regression test. A user with an $ip test account filter
-        reported the filtering wasn't working.
-
-        The filter wasn't triggering the "should join events" check, and so we didn't apply the filter at all
-        """
-        self.team.test_account_filters = [
-            {"key": "properties.is_internal_user == 'true'", "type": "hogql"},
-        ]
-        self.team.save()
-
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        Person.objects.create(
-            team=self.team,
-            distinct_ids=["user2"],
-            properties={"email": "not-the-other-one"},
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "1",
-                "$window_id": "1",
-                "is_internal_user": False,
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        produce_replay_summary(
-            distinct_id="user2",
-            session_id="2",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user2",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "2",
-                "$window_id": "1",
-                "is_internal_user": True,
-            },
-        )
-
-        # there are 2 pageviews
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # pageview that matches the hogql test_accounts filter
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": False,
-            }
-        )
-        self.assertEqual(len(session_recordings), 2)
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # only 1 pageview that matches the test_accounts filter
-                "filter_test_accounts": True,
-            }
-        )
-        self.assertEqual(len(session_recordings), 1)
-
-    @also_test_with_materialized_columns(person_properties=["email"], verify_no_jsonextract=False)
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_top_level_hogql_person_property_test_account_filter(self):
-        """
-        This is a regression test. A user with an $ip test account filter
-        reported the filtering wasn't working.
-
-        The filter wasn't triggering the "should join events" check, and so we didn't apply the filter at all
-        """
-        self.team.test_account_filters = [
-            {"key": "person.properties.email == 'bla'", "type": "hogql"},
-        ]
-        self.team.save()
-
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        Person.objects.create(
-            team=self.team,
-            distinct_ids=["user2"],
-            properties={"email": "not-the-other-one"},
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "1",
-                "$window_id": "1",
-                "is_internal_user": False,
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        produce_replay_summary(
-            distinct_id="user2",
-            session_id="2",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user2",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "2",
-                "$window_id": "1",
-                "is_internal_user": True,
-            },
-        )
-
-        # there are 2 pageviews
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # pageview that matches the hogql test_accounts filter
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": False,
-            }
-        )
-        self.assertEqual(len(session_recordings), 2)
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # only 1 pageview that matches the test_accounts filter
-                "filter_test_accounts": True,
-            }
-        )
-        self.assertEqual(len(session_recordings), 1)
-
-    @also_test_with_materialized_columns(person_properties=["email"], verify_no_jsonextract=False)
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_top_level_person_property_test_account_filter(self):
-        """
-        This is a regression test. A user with an $ip test account filter
-        reported the filtering wasn't working.
-
-        The filter wasn't triggering the "should join events" check, and so we didn't apply the filter at all
-        """
-        self.team.test_account_filters = [{"key": "email", "value": ["bla"], "operator": "exact", "type": "person"}]
-        self.team.save()
-
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        Person.objects.create(
-            team=self.team,
-            distinct_ids=["user2"],
-            properties={"email": "not-the-other-one"},
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "1",
-                "$window_id": "1",
-                "is_internal_user": False,
-            },
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-        )
-
-        produce_replay_summary(
-            distinct_id="user2",
-            session_id="2",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-        )
-        self.create_event(
-            "user2",
-            self.an_hour_ago,
-            properties={
-                "$session_id": "2",
-                "$window_id": "1",
-                "is_internal_user": True,
-            },
-        )
-
-        # there are 2 pageviews
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # pageview that matches the hogql test_accounts filter
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": False,
-            }
-        )
-        self.assertEqual(len(session_recordings), 2)
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # only 1 pageview that matches the test_accounts filter
-                "filter_test_accounts": True,
-            }
-        )
-        self.assertEqual(len(session_recordings), 1)
-
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_two_events_and_multiple_teams(self):
-        another_team = Team.objects.create(organization=self.organization)
-
-        # two teams, user with the same properties
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        Person.objects.create(team=another_team, distinct_ids=["user"], properties={"email": "bla"})
-
-        # a recording session with a pageview and a pageleave
-        self._a_session_with_two_events(self.team, "1")
-        self._a_session_with_two_events(another_team, "2")
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    },
-                    {
-                        "id": "$pageleave",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageleave",
-                    },
-                ],
-            }
-        )
-
-        self.assertEqual([sr["session_id"] for sr in session_recordings], ["1"])
-
-    def _a_session_with_two_events(self, team: Team, session_id: str) -> None:
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=team.pk,
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            team=team,
-            event_name="$pageview",
-            properties={"$session_id": session_id, "$window_id": "1"},
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            team=team,
-            event_name="$pageleave",
-            properties={"$session_id": session_id, "$window_id": "1"},
-        )
-
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_event_filter_with_group_filter(self):
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        session_id = f"test_event_filter_with_group_filter-ONE-{uuid4()}"
-        different_group_session = f"test_event_filter_with_group_filter-TWO-{uuid4()}"
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=session_id,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.pk,
-        )
-        produce_replay_summary(
-            distinct_id="user",
-            session_id=different_group_session,
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.pk,
-        )
-
-        GroupTypeMapping.objects.create(
-            team=self.team, project_id=self.team.project_id, group_type="project", group_type_index=0
-        )
-        create_group(
-            team_id=self.team.pk,
-            group_type_index=0,
-            group_key="project:1",
-            properties={"name": "project one"},
-        )
-
-        GroupTypeMapping.objects.create(
-            team=self.team, project_id=self.team.project_id, group_type="organization", group_type_index=1
-        )
-        create_group(
-            team_id=self.team.pk,
-            group_type_index=1,
-            group_key="org:1",
-            properties={"name": "org one"},
-        )
-
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            team=self.team,
-            event_name="$pageview",
-            properties={
-                "$session_id": session_id,
-                "$window_id": "1",
-                "$group_1": "org:1",
-            },
-        )
-        self.create_event(
-            "user",
-            self.an_hour_ago,
-            team=self.team,
-            event_name="$pageview",
-            properties={
-                "$session_id": different_group_session,
-                "$window_id": "1",
-                "$group_0": "project:1",
-            },
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                        "properties": [
-                            {
-                                "key": "name",
-                                "value": ["org one"],
-                                "operator": "exact",
-                                "type": "group",
-                                "group_type_index": 1,
-                            }
-                        ],
-                    }
-                ],
-            }
-        )
-
-        self.assertEqual([sr["session_id"] for sr in session_recordings], [session_id])
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "properties": [
-                    {
-                        "key": "name",
-                        "value": ["org one"],
-                        "operator": "exact",
-                        "type": "group",
-                        "group_type_index": 1,
-                    }
-                ],
-            }
-        )
-        self.assertEqual([sr["session_id"] for sr in session_recordings], [session_id])
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                "properties": [
-                    {
-                        "key": "name",
-                        "value": ["org one"],
-                        "operator": "exact",
-                        "type": "group",
-                        "group_type_index": 2,
-                    }
-                ],
-            }
-        )
-        self.assertEqual(session_recordings, [])
-
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_ordering(self):
-        session_id_one = f"test_ordering-one"
-        session_id_two = f"test_ordering-two"
-        session_id_three = f"test_ordering-three"
-
-        produce_replay_summary(
-            session_id=session_id_one,
-            team_id=self.team.id,
-            mouse_activity_count=50,
-            first_timestamp=(self.an_hour_ago + relativedelta(seconds=60)),
-        )
-        produce_replay_summary(
-            session_id=session_id_two,
-            team_id=self.team.id,
-            mouse_activity_count=100,
-            first_timestamp=(self.an_hour_ago),
-        )
-        produce_replay_summary(
-            session_id=session_id_three,
-            team_id=self.team.id,
-            mouse_activity_count=10,
-            first_timestamp=(self.an_hour_ago + relativedelta(minutes=10)),
-        )
-
-        (session_recordings, _, _) = self._filter_recordings_by({"order": "start_time"})
-        assert [r["session_id"] for r in session_recordings] == [session_id_three, session_id_one, session_id_two]
-
-        (session_recordings, _, _) = self._filter_recordings_by({"order": "mouse_activity_count"})
-        assert [r["session_id"] for r in session_recordings] == [session_id_two, session_id_one, session_id_three]
-
-    @also_test_with_materialized_columns(event_properties=["$host"], verify_no_jsonextract=False)
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_top_level_event_host_property_test_account_filter(self):
-        """
-        This is a regression test. See: https://posthoghelp.zendesk.com/agent/tickets/18059
-        """
-        self.team.test_account_filters = [
-            {"key": "$host", "type": "event", "value": "^(localhost|127\\.0\\.0\\.1)($|:)", "operator": "not_regex"},
-        ]
-        self.team.save()
-
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        Person.objects.create(
-            team=self.team,
-            distinct_ids=["user2"],
-            properties={"email": "not-the-other-one"},
-        )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            ensure_analytics_event_in_session=False,
-        )
-        # the session needs to have multiple matching or not matching events
-        for _ in range(10):
-            self.create_event(
-                "user",
-                self.an_hour_ago,
-                properties={
-                    "$session_id": "1",
-                    "$window_id": "1",
-                    "$host": "localhost",
-                },
-            )
-
-        produce_replay_summary(
-            distinct_id="user",
-            session_id="1",
-            first_timestamp=self.an_hour_ago + relativedelta(seconds=30),
-            team_id=self.team.id,
-            click_count=10,
-            ensure_analytics_event_in_session=False,
-        )
-
-        for _ in range(10):
-            self.create_event(
-                "user2",
-                self.an_hour_ago,
-                properties={
-                    "$session_id": "2",
-                    "$window_id": "1",
-                    "$host": "example.com",
-                },
-            )
-        produce_replay_summary(
-            distinct_id="user2",
-            session_id="2",
-            first_timestamp=self.an_hour_ago,
-            team_id=self.team.id,
-            click_count=10,
-            ensure_analytics_event_in_session=False,
-        )
-
-        # there are 2 pageviews
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # pageview that matches the hogql test_accounts filter
-                "events": [
-                    {
-                        "id": "$pageview",
-                        "type": "events",
-                        "order": 0,
-                        "name": "$pageview",
-                    }
-                ],
-                "filter_test_accounts": False,
-            }
-        )
-        self.assertEqual(len(session_recordings), 2)
-
-        (session_recordings, _, _) = self._filter_recordings_by(
-            {
-                # only 1 pageview that matches the test_accounts filter
-                "filter_test_accounts": True,
-            }
-        )
-        assert session_recordings == [
-            {
-                "active_seconds": 0.0,
-                "activity_score": 0.28,
-                "click_count": 10,  # in the bug this value was 10 X number of events in the session
-                "console_error_count": 0,
-                "console_log_count": 0,
-                "console_warn_count": 0,
-                "distinct_id": "user2",
-                "duration": 3600,
-                "end_time": ANY,
-                "first_url": "https://not-provided-by-test.com",
-                "inactive_seconds": 3600.0,
-                "keypress_count": 0,
-                "mouse_activity_count": 0,
-                "session_id": "2",
-                "start_time": ANY,
-                "team_id": self.team.id,
-                "ongoing": 1,
-            }
-        ]
diff --git a/posthog/session_recordings/queries/test/test_session_recording_list_from_query.py b/posthog/session_recordings/queries/test/test_session_recording_list_from_query.py
index abfd8ab98b956..35116f4085e55 100644
--- a/posthog/session_recordings/queries/test/test_session_recording_list_from_query.py
+++ b/posthog/session_recordings/queries/test/test_session_recording_list_from_query.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, UTC
 from typing import Literal
 from unittest.mock import ANY
 from uuid import uuid4
@@ -11,11 +11,12 @@
 from posthog.clickhouse.client import sync_execute
 from posthog.clickhouse.log_entries import TRUNCATE_LOG_ENTRIES_TABLE_SQL
 from posthog.constants import AvailableFeature
+from posthog.hogql_queries.utils.query_date_range import QueryDateRange
 from posthog.models import Cohort, GroupTypeMapping, Person
 from posthog.models.action import Action
 from posthog.models.group.util import create_group
 from posthog.models.team import Team
-from posthog.schema import RecordingsQuery
+from posthog.schema import RecordingsQuery, DateRange
 from posthog.session_recordings.queries.session_recording_list_from_query import (
     SessionRecordingQueryResult,
 )
@@ -38,6 +39,74 @@
 )
 
 
+@freeze_time("2021-01-01T13:46:23")
+class TestSessionRecordingQueryDateRange(APIBaseTest):
+    def test_with_relative_dates(self) -> None:
+        query_date_range = QueryDateRange(
+            date_range=DateRange(date_from="-3d", date_to="-24h", explicitDate=True),
+            team=self.team,
+            interval=None,
+            now=datetime.now(UTC),
+        )
+
+        assert query_date_range.date_from() == datetime(2020, 12, 29, 0, 0, 0, 0, UTC)
+        assert query_date_range.date_to() == datetime(
+            year=2020, month=12, day=31, hour=13, minute=46, second=23, tzinfo=UTC
+        )
+
+    def test_with_string_dates(self) -> None:
+        query_date_range = QueryDateRange(
+            date_range=DateRange(date_from="2020-12-29", date_to="2021-01-01", explicitDate=True),
+            team=self.team,
+            interval=None,
+            now=datetime.now(UTC),
+        )
+
+        assert query_date_range.date_from() == datetime(2020, 12, 29, 0, 0, 0, 0, UTC)
+        assert query_date_range.date_to() == datetime(year=2021, month=1, day=1, hour=0, minute=0, second=0, tzinfo=UTC)
+
+    def test_with_string_date_times(self) -> None:
+        query_date_range = QueryDateRange(
+            date_range=DateRange(date_from="2020-12-29T12:23:45Z", date_to="2021-01-01T13:34:42Z", explicitDate=True),
+            team=self.team,
+            interval=None,
+            now=datetime.now(UTC),
+        )
+
+        assert query_date_range.date_from() == datetime(2020, 12, 29, 12, 23, 45, tzinfo=UTC)
+        assert query_date_range.date_to() == datetime(
+            year=2021, month=1, day=1, hour=13, minute=34, second=42, tzinfo=UTC
+        )
+
+    def test_with_no_date_from(self) -> None:
+        query_date_range = QueryDateRange(
+            date_range=DateRange(date_from=None, date_to="2021-01-01T13:34:42Z", explicitDate=True),
+            team=self.team,
+            interval=None,
+            now=datetime.now(UTC),
+        )
+
+        # defaults to start of 7 days ago
+        assert query_date_range.date_from() == datetime(2020, 12, 25, 0, 0, 0, 0, UTC)
+        assert query_date_range.date_to() == datetime(
+            year=2021, month=1, day=1, hour=13, minute=34, second=42, tzinfo=UTC
+        )
+
+    def test_with_no_date_to(self) -> None:
+        query_date_range = QueryDateRange(
+            date_range=DateRange(date_from="2021-01-01T11:34:42Z", date_to=None, explicitDate=True),
+            team=self.team,
+            interval=None,
+            now=datetime.now(UTC),
+        )
+
+        assert query_date_range.date_from() == datetime(2021, 1, 1, 11, 34, 42, tzinfo=UTC)
+        # defaults to now
+        assert query_date_range.date_to() == datetime(
+            year=2021, month=1, day=1, hour=13, minute=46, second=23, tzinfo=UTC
+        )
+
+
 @freeze_time("2021-01-01T13:46:23")
 class TestSessionRecordingsListFromQuery(ClickhouseTestMixin, APIBaseTest):
     def setUp(self):
@@ -778,6 +847,9 @@ def test_listing_ignores_future_replays(self):
         with freeze_time("2023-08-29T12:00:01Z"):
             produce_replay_summary(team_id=self.team.id, session_id="29th Aug")
 
+        with freeze_time("2023-08-30T14:00:01Z"):
+            produce_replay_summary(team_id=self.team.id, session_id="30th Aug 1400")
+
         with freeze_time("2023-09-01T12:00:01Z"):
             produce_replay_summary(team_id=self.team.id, session_id="1st-sep")
 
@@ -787,6 +859,7 @@ def test_listing_ignores_future_replays(self):
         with freeze_time("2023-09-03T12:00:01Z"):
             produce_replay_summary(team_id=self.team.id, session_id="3rd-sep")
 
+        # before the recording on the thirtieth so should exclude it
         with freeze_time("2023-08-30T12:00:01Z"):
             recordings = self._filter_recordings_by()
 
@@ -1896,11 +1969,11 @@ def test_date_to_filter(self):
         )
         assert session_recordings == []
 
+        # we have to change this test because the behavior of the API did change 🙈
         (session_recordings, _, _) = self._filter_recordings_by(
-            {"date_to": (self.an_hour_ago - relativedelta(days=3)).strftime("%Y-%m-%d")}
+            {"date_to": (self.an_hour_ago - relativedelta(days=3)).strftime("%Y-%m-%dT%H:%M:%S")}
         )
 
-        assert len(session_recordings) == 1
         assert [s["session_id"] for s in session_recordings] == ["three days before base time"]
 
     def test_recording_that_spans_time_bounds(self):
diff --git a/posthog/session_recordings/queries/test/test_session_recording_properties.py b/posthog/session_recordings/queries/test/test_session_recording_properties.py
deleted file mode 100644
index 7972eb742abb0..0000000000000
--- a/posthog/session_recordings/queries/test/test_session_recording_properties.py
+++ /dev/null
@@ -1,104 +0,0 @@
-from dateutil.relativedelta import relativedelta
-from django.utils.timezone import now
-from freezegun.api import freeze_time
-
-from posthog.models import Person
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
-from posthog.session_recordings.queries.session_recording_properties import (
-    SessionRecordingProperties,
-)
-from posthog.session_recordings.queries.test.session_replay_sql import (
-    produce_replay_summary,
-)
-from posthog.test.base import (
-    BaseTest,
-    ClickhouseTestMixin,
-    _create_event,
-    snapshot_clickhouse_queries,
-)
-
-
-class TestSessionRecordingProperties(BaseTest, ClickhouseTestMixin):
-    def create_event(
-        self,
-        distinct_id,
-        timestamp,
-        team=None,
-        event_name="$pageview",
-        properties=None,
-    ):
-        if properties is None:
-            properties = {"$os": "Windows 95", "$current_url": "aloha.com/2"}
-        if team is None:
-            team = self.team
-        _create_event(
-            team=team,
-            event=event_name,
-            timestamp=timestamp,
-            distinct_id=distinct_id,
-            properties=properties,
-        )
-
-    @property
-    def base_time(self):
-        return now() - relativedelta(hours=1)
-
-    @freeze_time("2021-01-21T20:00:00.000Z")
-    @snapshot_clickhouse_queries
-    def test_properties_list(self):
-        Person.objects.create(team=self.team, distinct_ids=["user"], properties={"email": "bla"})
-        produce_replay_summary(
-            team_id=self.team.id,
-            session_id="1",
-            distinct_id="user",
-            first_timestamp=self.base_time,
-            last_timestamp=self.base_time,
-        )
-        produce_replay_summary(
-            team_id=self.team.id,
-            session_id="2",
-            distinct_id="user",
-            first_timestamp=self.base_time,
-            last_timestamp=self.base_time,
-        )
-
-        event_props = {
-            "$session_id": "1",
-            "$window_id": "1",
-            "should_not_be_included": "1",
-            "$browser": "Chrome",
-            "$os": "Mac OS X",
-            "$device_type": "Desktop",
-            "$current_url": "https://blah.com/blah",
-            "$host": "blah.com",
-            "$pathname": "/blah",
-            "$geoip_country_code": "KR",
-        }
-        self.create_event(
-            "user",
-            self.base_time,
-            properties=event_props,
-        )
-        self.create_event(
-            "user",
-            self.base_time,
-            properties=event_props,
-        )
-
-        filter = SessionRecordingsFilter(team=self.team, data={"no_filter": None})
-        session_recording_properties_instance = SessionRecordingProperties(
-            filter=filter, team=self.team, session_ids=["1"]
-        )
-        session_recordings_properties = session_recording_properties_instance.run()
-        self.assertEqual(len(session_recordings_properties), 1)
-        self.assertEqual(session_recordings_properties[0]["properties"]["$browser"], "Chrome")
-        self.assertEqual(session_recordings_properties[0]["properties"]["$os"], "Mac OS X")
-        self.assertEqual(session_recordings_properties[0]["properties"]["$device_type"], "Desktop")
-        self.assertEqual(
-            session_recordings_properties[0]["properties"]["$current_url"],
-            "https://blah.com/blah",
-        )
-        self.assertEqual(session_recordings_properties[0]["properties"]["$host"], "blah.com")
-        self.assertEqual(session_recordings_properties[0]["properties"]["$pathname"], "/blah")
-        self.assertEqual(session_recordings_properties[0]["properties"]["$geoip_country_code"], "KR")
-        self.assertNotIn("should_not_be_included", session_recordings_properties[0]["properties"])
diff --git a/posthog/session_recordings/session_recording_api.py b/posthog/session_recordings/session_recording_api.py
index 0b9ea6e40d48c..979a4b1983967 100644
--- a/posthog/session_recordings/session_recording_api.py
+++ b/posthog/session_recordings/session_recording_api.py
@@ -21,16 +21,15 @@
 from rest_framework.response import Response
 from rest_framework.utils.encoders import JSONEncoder
 
+import posthog.session_recordings.queries.session_recording_list_from_query
 from ee.session_recordings.session_summary.summarize_session import summarize_recording
 from posthog.api.person import MinimalPersonSerializer
 from posthog.api.routing import TeamAndOrgViewSetMixin
 from posthog.api.utils import action, safe_clickhouse_string
 from posthog.auth import PersonalAPIKeyAuthentication, SharingAccessTokenAuthentication
 from posthog.cloud_utils import is_cloud
-from posthog.constants import SESSION_RECORDINGS_FILTER_IDS
 from posthog.event_usage import report_user_action
 from posthog.models import Team, User
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
 from posthog.models.person.person import PersonDistinctId
 from posthog.rate_limit import (
     ClickHouseBurstRateThrottle,
@@ -42,14 +41,7 @@
 from posthog.session_recordings.models.session_recording_event import (
     SessionRecordingViewed,
 )
-from posthog.session_recordings.queries.session_recording_list_from_filters import (
-    ReplayFiltersEventsSubQuery,
-    SessionRecordingListFromFilters,
-)
 from posthog.session_recordings.queries.session_recording_list_from_query import SessionRecordingListFromQuery
-from posthog.session_recordings.queries.session_recording_properties import (
-    SessionRecordingProperties,
-)
 from posthog.session_recordings.queries.session_replay_events import SessionReplayEvents
 from posthog.session_recordings.realtime_snapshots import (
     get_realtime_snapshots,
@@ -336,19 +328,15 @@ def safely_get_object(self, queryset) -> SessionRecording:
         return recording
 
     def list(self, request: request.Request, *args: Any, **kwargs: Any) -> Response:
-        use_query_type = (request.GET.get("as_query", "False")).lower() == "true"
-        if use_query_type:
-            data_dict = query_as_params_to_dict(request.GET.dict())
-            query = RecordingsQuery.model_validate(data_dict)
-            # a little duplication for now
-            self._maybe_report_recording_list_filters_changed(request, team=self.team)
-            return list_recordings_response(
-                list_recordings_from_query(query, request, context=self.get_serializer_context())
-            )
-        else:
-            filter = SessionRecordingsFilter(request=request, team=self.team)
-            self._maybe_report_recording_list_filters_changed(request, team=self.team)
-            return list_recordings_response(list_recordings(filter, request, context=self.get_serializer_context()))
+        data_dict = query_as_params_to_dict(request.GET.dict())
+        # we used to send `version` and it's not part of query, so we pop to make sure
+        data_dict.pop("version", None)
+        query = RecordingsQuery.model_validate(data_dict)
+
+        self._maybe_report_recording_list_filters_changed(request, team=self.team)
+        return list_recordings_response(
+            list_recordings_from_query(query, request, context=self.get_serializer_context())
+        )
 
     @extend_schema(
         exclude=True,
@@ -360,31 +348,32 @@ def list(self, request: request.Request, *args: Any, **kwargs: Any) -> Response:
     )
     @action(methods=["GET"], detail=False)
     def matching_events(self, request: request.Request, *args: Any, **kwargs: Any) -> JsonResponse:
-        filter = SessionRecordingsFilter(request=request, team=self.team)
+        data_dict = query_as_params_to_dict(request.GET.dict())
+        query = RecordingsQuery.model_validate(data_dict)
 
-        if not filter.session_ids or len(filter.session_ids) != 1:
+        if not query.session_ids or len(query.session_ids) != 1:
             raise exceptions.ValidationError(
                 "Must specify exactly one session_id",
             )
 
-        if not filter.events and not filter.actions:
+        if not query.events and not query.actions:
             raise exceptions.ValidationError(
                 "Must specify at least one event or action filter",
             )
 
         distinct_id = str(cast(User, request.user).distinct_id)
         modifiers = safely_read_modifiers_overrides(distinct_id, self.team)
-        matching_events_query_response = ReplayFiltersEventsSubQuery(
-            filter=filter, team=self.team, hogql_query_modifiers=modifiers
-        ).get_event_ids_for_session()
+        results, _, timings = (
+            posthog.session_recordings.queries.session_recording_list_from_query.ReplayFiltersEventsSubQuery(
+                query=query, team=self.team, hogql_query_modifiers=modifiers
+            ).get_event_ids_for_session()
+        )
 
-        response = JsonResponse(data={"results": matching_events_query_response.results})
+        response = JsonResponse(data={"results": results})
 
         response.headers["Server-Timing"] = ", ".join(
             f"{key};dur={round(duration, ndigits=2)}"
-            for key, duration in _generate_timings(
-                matching_events_query_response.timings, ServerTimingsGathered()
-            ).items()
+            for key, duration in _generate_timings(timings, ServerTimingsGathered()).items()
         )
         return response
 
@@ -642,32 +631,6 @@ def _distinct_id_from_request(request):
         else:
             return "anonymous"
 
-    # Returns properties given a list of session recording ids
-    @extend_schema(exclude=True)
-    @action(methods=["GET"], detail=False)
-    def properties(self, request: request.Request, **kwargs):
-        filter = SessionRecordingsFilter(request=request, team=self.team)
-        session_ids = [
-            recording_id for recording_id in json.loads(self.request.GET.get("session_ids", "[]")) if recording_id
-        ]
-        for session_id in session_ids:
-            if not isinstance(session_id, str):
-                raise exceptions.ValidationError(f"Invalid session_id: {session_id} - not a string")
-        session_recordings_properties = SessionRecordingProperties(
-            team=self.team, filter=filter, session_ids=session_ids
-        ).run()
-
-        if not request.user.is_authenticated:  # for mypy
-            raise exceptions.NotAuthenticated()
-
-        session_recording_serializer = SessionRecordingPropertiesSerializer(
-            data=session_recordings_properties, many=True
-        )
-
-        session_recording_serializer.is_valid(raise_exception=True)
-
-        return Response({"results": session_recording_serializer.data})
-
     @extend_schema(exclude=True)
     @action(methods=["POST"], detail=True)
     def summarize(self, request: request.Request, **kwargs):
@@ -921,106 +884,6 @@ def list_recordings_from_query(
     )
 
 
-def list_recordings(
-    filter: SessionRecordingsFilter, request: request.Request, context: dict[str, Any]
-) -> tuple[dict, dict]:
-    """
-    As we can store recordings in S3 or in Clickhouse we need to do a few things here
-
-    A. If filter.session_ids is specified:
-      1. We first try to load them directly from Postgres if they have been persisted to S3 (they might have fell out of CH)
-      2. Any that couldn't be found are then loaded from Clickhouse
-    B. Otherwise we just load all values from Clickhouse
-      2. Once loaded we convert them to SessionRecording objects in case we have any other persisted data
-    """
-
-    all_session_ids = filter.session_ids
-
-    recordings: list[SessionRecording] = []
-    more_recordings_available = False
-    team = context["get_team"]()
-    hogql_timings: list[QueryTiming] | None = None
-
-    timer = ServerTimingsGathered()
-
-    if all_session_ids:
-        with timer("load_persisted_recordings"):
-            # If we specify the session ids (like from pinned recordings) we can optimise by only going to Postgres
-            sorted_session_ids = sorted(all_session_ids)
-
-            persisted_recordings_queryset = SessionRecording.objects.filter(
-                team=team, session_id__in=sorted_session_ids
-            ).exclude(object_storage_path=None)
-
-            persisted_recordings = persisted_recordings_queryset.all()
-
-            recordings = recordings + list(persisted_recordings)
-
-            remaining_session_ids = list(set(all_session_ids) - {x.session_id for x in persisted_recordings})
-            filter = filter.shallow_clone({SESSION_RECORDINGS_FILTER_IDS: remaining_session_ids})
-
-    if (all_session_ids and filter.session_ids) or not all_session_ids:
-        distinct_id = str(cast(User, request.user).distinct_id)
-        modifiers = safely_read_modifiers_overrides(distinct_id, team)
-
-        with timer("load_recordings_from_hogql"):
-            (ch_session_recordings, more_recordings_available, hogql_timings) = SessionRecordingListFromFilters(
-                filter=filter, team=team, hogql_query_modifiers=modifiers
-            ).run()
-
-        with timer("build_recordings"):
-            recordings_from_clickhouse = SessionRecording.get_or_build_from_clickhouse(team, ch_session_recordings)
-            recordings = recordings + recordings_from_clickhouse
-
-            recordings = [x for x in recordings if not x.deleted]
-
-            # If we have specified session_ids we need to sort them by the order they were specified
-            if all_session_ids:
-                recordings = sorted(
-                    recordings,
-                    key=lambda x: cast(list[str], all_session_ids).index(x.session_id),
-                )
-
-    if not request.user.is_authenticated:  # for mypy
-        raise exceptions.NotAuthenticated()
-
-    # Update the viewed status for all loaded recordings
-    with timer("load_viewed_recordings"):
-        viewed_session_recordings = set(
-            SessionRecordingViewed.objects.filter(team=team, user=request.user).values_list("session_id", flat=True)
-        )
-
-    with timer("load_persons"):
-        # Get the related persons for all the recordings
-        distinct_ids = sorted([x.distinct_id for x in recordings if x.distinct_id])
-        person_distinct_ids = PersonDistinctId.objects.filter(distinct_id__in=distinct_ids, team=team).select_related(
-            "person"
-        )
-
-    with timer("process_persons"):
-        distinct_id_to_person = {}
-        for person_distinct_id in person_distinct_ids:
-            person_distinct_id.person._distinct_ids = [
-                person_distinct_id.distinct_id
-            ]  # Stop the person from loading all distinct ids
-            distinct_id_to_person[person_distinct_id.distinct_id] = person_distinct_id.person
-
-        for recording in recordings:
-            recording.viewed = recording.session_id in viewed_session_recordings
-            person = distinct_id_to_person.get(recording.distinct_id) if recording.distinct_id else None
-            if person:
-                recording.person = person
-
-    session_recording_serializer = SessionRecordingSerializer(recordings, context=context, many=True)
-    results = session_recording_serializer.data
-
-    all_timings = _generate_timings(hogql_timings, timer)
-    return (
-        {"results": results, "has_next": more_recordings_available, "version": 3},
-        all_timings,
-    )
-
-
 def safely_read_modifiers_overrides(distinct_id: str, team: Team) -> HogQLQueryModifiers:
     modifiers = HogQLQueryModifiers()
 
diff --git a/posthog/session_recordings/sql/session_replay_event_migrations_sql.py b/posthog/session_recordings/sql/session_replay_event_migrations_sql.py
index 808a89dc41c13..684206e6aef5b 100644
--- a/posthog/session_recordings/sql/session_replay_event_migrations_sql.py
+++ b/posthog/session_recordings/sql/session_replay_event_migrations_sql.py
@@ -114,3 +114,45 @@
     table_name=SESSION_REPLAY_EVENTS_DATA_TABLE(),
     cluster=settings.CLICKHOUSE_CLUSTER,
 )
+
+# migration to add all_urls column to the session replay table
+ALTER_SESSION_REPLAY_ADD_ALL_URLS_COLUMN = """
+    ALTER TABLE {table_name} on CLUSTER '{cluster}'
+    ADD COLUMN IF NOT EXISTS all_urls SimpleAggregateFunction(groupUniqArrayArray, Array(String))
+"""
+
+ADD_ALL_URLS_DISTRIBUTED_SESSION_REPLAY_EVENTS_TABLE_SQL = lambda: ALTER_SESSION_REPLAY_ADD_ALL_URLS_COLUMN.format(
+    table_name="session_replay_events",
+    cluster=settings.CLICKHOUSE_CLUSTER,
+)
+
+ADD_ALL_URLS_WRITABLE_SESSION_REPLAY_EVENTS_TABLE_SQL = lambda: ALTER_SESSION_REPLAY_ADD_ALL_URLS_COLUMN.format(
+    table_name="writable_session_replay_events",
+    cluster=settings.CLICKHOUSE_CLUSTER,
+)
+
+ADD_ALL_URLS_SESSION_REPLAY_EVENTS_TABLE_SQL = lambda: ALTER_SESSION_REPLAY_ADD_ALL_URLS_COLUMN.format(
+    table_name=SESSION_REPLAY_EVENTS_DATA_TABLE(),
+    cluster=settings.CLICKHOUSE_CLUSTER,
+)
+
+# migration to add library column to the session replay table
+ALTER_SESSION_REPLAY_ADD_LIBRARY_COLUMN = """
+    ALTER TABLE {table_name} on CLUSTER '{cluster}'
+    ADD COLUMN IF NOT EXISTS snapshot_library AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC'))
+"""
+
+ADD_LIBRARY_DISTRIBUTED_SESSION_REPLAY_EVENTS_TABLE_SQL = lambda: ALTER_SESSION_REPLAY_ADD_LIBRARY_COLUMN.format(
+    table_name="session_replay_events",
+    cluster=settings.CLICKHOUSE_CLUSTER,
+)
+
+ADD_LIBRARY_WRITABLE_SESSION_REPLAY_EVENTS_TABLE_SQL = lambda: ALTER_SESSION_REPLAY_ADD_LIBRARY_COLUMN.format(
+    table_name="writable_session_replay_events",
+    cluster=settings.CLICKHOUSE_CLUSTER,
+)
+
+ADD_LIBRARY_SESSION_REPLAY_EVENTS_TABLE_SQL = lambda: ALTER_SESSION_REPLAY_ADD_LIBRARY_COLUMN.format(
+    table_name=SESSION_REPLAY_EVENTS_DATA_TABLE(),
+    cluster=settings.CLICKHOUSE_CLUSTER,
+)
diff --git a/posthog/session_recordings/sql/session_replay_event_sql.py b/posthog/session_recordings/sql/session_replay_event_sql.py
index ccec36c2b9f39..09c8f343540e8 100644
--- a/posthog/session_recordings/sql/session_replay_event_sql.py
+++ b/posthog/session_recordings/sql/session_replay_event_sql.py
@@ -24,6 +24,7 @@
     first_timestamp DateTime64(6, 'UTC'),
     last_timestamp DateTime64(6, 'UTC'),
     first_url Nullable(VARCHAR),
+    urls Array(String),
     click_count Int64,
     keypress_count Int64,
     mouse_activity_count Int64,
@@ -34,7 +35,8 @@
     size Int64,
     event_count Int64,
     message_count Int64,
-    snapshot_source LowCardinality(Nullable(String))
+    snapshot_source LowCardinality(Nullable(String)),
+    snapshot_library Nullable(String)
 ) ENGINE = {engine}
 """
 
@@ -53,7 +55,11 @@
     distinct_id VARCHAR,
     min_first_timestamp SimpleAggregateFunction(min, DateTime64(6, 'UTC')),
     max_last_timestamp SimpleAggregateFunction(max, DateTime64(6, 'UTC')),
+    -- store the first url of the session so we can quickly show that in playlists
     first_url AggregateFunction(argMin, Nullable(VARCHAR), DateTime64(6, 'UTC')),
+    -- but also store each url so we can query by visited page without having to scan all events
+    -- despite the name we can put mobile screens in here as well to give same functionality across platforms
+    all_urls SimpleAggregateFunction(groupUniqArrayArray, Array(String)),
     click_count SimpleAggregateFunction(sum, Int64),
     keypress_count SimpleAggregateFunction(sum, Int64),
     mouse_activity_count SimpleAggregateFunction(sum, Int64),
@@ -70,8 +76,10 @@
     -- often very useful in incidents or debugging
     -- because we batch events we expect message_count to be lower than event_count
     event_count SimpleAggregateFunction(sum, Int64),
-    -- which source the snapshots came from Android, iOS, Mobile, Web. Web if absent
+    -- which source the snapshots came from Mobile or Web. Web if absent
     snapshot_source AggregateFunction(argMin, LowCardinality(Nullable(String)), DateTime64(6, 'UTC')),
+    -- knowing something is mobile isn't enough, we need to know if e.g. RN or flutter
+    snapshot_library AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
     _timestamp SimpleAggregateFunction(max, DateTime)
 ) ENGINE = {engine}
 """
@@ -129,6 +137,7 @@
 -- this is an aggregate function, not a simple aggregate function
 -- so we have to write to argMinState, and query with argMinMerge
 argMinState(first_url, first_timestamp) as first_url,
+groupUniqArrayArray(urls) as all_urls,
 sum(click_count) as click_count,
 sum(keypress_count) as keypress_count,
 sum(mouse_activity_count) as mouse_activity_count,
@@ -141,6 +150,7 @@
 sum(message_count) as message_count,
 sum(event_count) as event_count,
 argMinState(snapshot_source, first_timestamp) as snapshot_source,
+argMinState(snapshot_library, first_timestamp) as snapshot_library,
 max(_timestamp) as _timestamp
 FROM {database}.kafka_session_replay_events
 group by session_id, team_id
@@ -156,12 +166,14 @@
 `min_first_timestamp` DateTime64(6, 'UTC'),
 `max_last_timestamp` DateTime64(6, 'UTC'),
 `first_url` AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
+`all_urls` SimpleAggregateFunction(groupUniqArrayArray, Array(String)),
 `click_count` Int64, `keypress_count` Int64,
 `mouse_activity_count` Int64, `active_milliseconds` Int64,
 `console_log_count` Int64, `console_warn_count` Int64,
 `console_error_count` Int64, `size` Int64, `message_count` Int64,
 `event_count` Int64,
 `snapshot_source` AggregateFunction(argMin, LowCardinality(Nullable(String)), DateTime64(6, 'UTC')),
+`snapshot_library` AggregateFunction(argMin, Nullable(String), DateTime64(6, 'UTC')),
 `_timestamp` Nullable(DateTime)
 )""",
     )
diff --git a/posthog/session_recordings/test/__snapshots__/test_session_recordings.ambr b/posthog/session_recordings/test/__snapshots__/test_session_recordings.ambr
index 88a534a569646..c25bdb4d587b4 100644
--- a/posthog/session_recordings/test/__snapshots__/test_session_recordings.ambr
+++ b/posthog/session_recordings/test/__snapshots__/test_session_recordings.ambr
@@ -738,7 +738,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_get_session_recordings.24
@@ -865,7 +865,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_get_session_recordings.28
@@ -1637,7 +1637,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.100
@@ -1788,7 +1788,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.105
@@ -1915,7 +1915,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.109
@@ -2543,7 +2543,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.125
@@ -2670,7 +2670,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.129
@@ -3234,7 +3234,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.145
@@ -3361,7 +3361,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.149
@@ -3988,7 +3988,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.165
@@ -4115,7 +4115,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.169
@@ -4706,7 +4706,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.185
@@ -4833,7 +4833,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.189
@@ -5506,7 +5506,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.205
@@ -5633,7 +5633,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.209
@@ -5940,7 +5940,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.25
@@ -6067,7 +6067,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.29
@@ -6671,7 +6671,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.45
@@ -6798,7 +6798,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.49
@@ -7214,7 +7214,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.60
@@ -7365,7 +7365,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.65
@@ -7492,7 +7492,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.69
@@ -8116,7 +8116,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.85
@@ -8243,7 +8243,7 @@
          "posthog_grouptypemapping"."name_singular",
          "posthog_grouptypemapping"."name_plural"
   FROM "posthog_grouptypemapping"
-  WHERE "posthog_grouptypemapping"."team_id" = 99999
+  WHERE "posthog_grouptypemapping"."project_id" = 99999
   '''
 # ---
 # name: TestSessionRecordings.test_listing_recordings_is_not_nplus1_for_persons.89
diff --git a/posthog/session_recordings/test/test_session_recordings.py b/posthog/session_recordings/test/test_session_recordings.py
index f3c7d7edfa38d..561d30ea83b02 100644
--- a/posthog/session_recordings/test/test_session_recordings.py
+++ b/posthog/session_recordings/test/test_session_recordings.py
@@ -14,10 +14,7 @@
 from rest_framework import status
 
 from posthog.api.test.test_team import create_team
-from posthog.constants import SESSION_RECORDINGS_FILTER_IDS
 from posthog.models import Organization, Person, SessionRecording
-from posthog.models.filters.session_recordings_filter import SessionRecordingsFilter
-from posthog.models.property import Property
 from posthog.models.team import Team
 from posthog.schema import RecordingsQuery, LogEntryPropertyFilter
 from posthog.session_recordings.models.session_recording_event import (
@@ -90,7 +87,8 @@ def test_get_session_recordings(self):
         session_id_two = f"test_get_session_recordings-2"
         self.produce_replay_summary("user2", session_id_two, base_time + relativedelta(seconds=20))
 
-        response = self.client.get(f"/api/projects/{self.team.id}/session_recordings")
+        # include `as_query` since we don't want to break while deploying the code that no longer needs it
+        response = self.client.get(f"/api/projects/{self.team.id}/session_recordings?as_query=true")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         response_data = response.json()
 
@@ -171,46 +169,8 @@ def test_can_list_recordings_even_when_the_person_has_multiple_distinct_ids(self
         assert results_[1]["distinct_id"] in twelve_distinct_ids
 
     @patch("posthoganalytics.capture")
-    @patch("posthog.session_recordings.session_recording_api.SessionRecordingListFromFilters")
-    @patch("posthog.session_recordings.session_recording_api.list_recordings_from_query")
-    def test_console_log_filters_are_correctly_passed_to_listing_when_filters_are_used(
-        self, mock_query_lister, mock_summary_lister, mock_capture
-    ):
-        mock_summary_lister.return_value.run.return_value = ([], False)
-        mock_query_lister.return_value.run.return_value = ([], False)
-
-        params_string = urlencode(
-            {
-                "console_log_filters": '[{"key": "console_log_level", "value": ["warn", "error"], "operator": "exact", "type": "log_entry"}]',
-                "user_modified_filters": '{"my_filter": "something"}',
-                "as_query": False,
-            }
-        )
-        self.client.get(f"/api/projects/{self.team.id}/session_recordings?{params_string}")
-
-        assert len(mock_summary_lister.call_args_list) == 1
-        assert len(mock_query_lister.call_args_list) == 0
-        filter_passed_to_mock: SessionRecordingsFilter = mock_summary_lister.call_args_list[0].kwargs["filter"]
-        console_filter = cast(Property, filter_passed_to_mock.console_log_filters.values[0])
-        assert console_filter.value == ["warn", "error"]
-        assert mock_capture.call_args_list[0] == call(
-            self.user.distinct_id,
-            "recording list filters changed",
-            properties={
-                "$current_url": ANY,
-                "$session_id": ANY,
-                "partial_filter_chosen_my_filter": "something",
-            },
-            groups=ANY,
-        )
-
-    @patch("posthoganalytics.capture")
-    @patch("posthog.session_recordings.session_recording_api.SessionRecordingListFromFilters")
     @patch("posthog.session_recordings.session_recording_api.list_recordings_from_query")
-    def test_console_log_filters_are_correctly_passed_to_listing_when_query_is_used(
-        self, mock_query_lister, mock_summary_lister, mock_capture
-    ):
-        mock_summary_lister.return_value.run.return_value = ([], False)
+    def test_console_log_filters_are_correctly_passed_to_listing(self, mock_query_lister, mock_capture):
         mock_query_lister.return_value = ([], False)
 
         params_string = urlencode(
@@ -222,7 +182,6 @@ def test_console_log_filters_are_correctly_passed_to_listing_when_query_is_used(
         )
         self.client.get(f"/api/projects/{self.team.id}/session_recordings?{params_string}")
 
-        assert len(mock_summary_lister.call_args_list) == 0
         assert len(mock_query_lister.call_args_list) == 1
         query_passed_to_mock: RecordingsQuery = mock_query_lister.call_args_list[0][0][0]
         maybe_the_filter = (
@@ -1104,7 +1063,7 @@ def test_get_via_sharing_token(self, mock_copy_objects: MagicMock) -> None:
 
     def test_get_matching_events_for_must_not_send_multiple_session_ids(self) -> None:
         query_params = [
-            f'{SESSION_RECORDINGS_FILTER_IDS}=["{str(uuid.uuid4())}", "{str(uuid.uuid4())}"]',
+            f'session_ids=["{str(uuid.uuid4())}", "{str(uuid.uuid4())}"]',
         ]
         response = self.client.get(
             f"/api/projects/{self.team.id}/session_recordings/matching_events?{'&'.join(query_params)}"
@@ -1129,7 +1088,7 @@ def test_get_matching_events_for_must_send_a_single_session_id_filter(self) -> N
 
     def test_get_matching_events_for_must_send_at_least_an_event_filter(self) -> None:
         query_params = [
-            f'{SESSION_RECORDINGS_FILTER_IDS}=["{str(uuid.uuid4())}"]',
+            f'session_ids=["{str(uuid.uuid4())}"]',
         ]
 
         response = self.client.get(
@@ -1146,7 +1105,7 @@ def test_get_matching_events_for_must_send_at_least_an_event_filter(self) -> Non
     def test_get_matching_events_for_unknown_session(self) -> None:
         session_id = str(uuid.uuid4())
         query_params = [
-            f'{SESSION_RECORDINGS_FILTER_IDS}=["{session_id}"]',
+            f'session_ids=["{session_id}"]',
             'events=[{"id": "$pageview", "type": "events", "order": 0, "name": "$pageview"}]',
         ]
         response = self.client.get(
@@ -1155,6 +1114,45 @@ def test_get_matching_events_for_unknown_session(self) -> None:
         assert response.status_code == status.HTTP_200_OK
         assert response.json() == {"results": []}
 
+    def test_get_matching_events_with_query(self) -> None:
+        base_time = (now() - relativedelta(days=1)).replace(microsecond=0)
+
+        # the matching session
+        session_id = f"test_get_matching_events-1-{uuid.uuid4()}"
+        self.produce_replay_summary("user", session_id, base_time)
+        event_id = _create_event(
+            event="$pageview",
+            properties={"$session_id": session_id},
+            team=self.team,
+            distinct_id=uuid.uuid4(),
+        )
+
+        # a non-matching session
+        non_matching_session_id = f"test_get_matching_events-2-{uuid.uuid4()}"
+        self.produce_replay_summary("user", non_matching_session_id, base_time)
+        _create_event(
+            event="$pageview",
+            properties={"$session_id": non_matching_session_id},
+            team=self.team,
+            distinct_id=uuid.uuid4(),
+        )
+
+        flush_persons_and_events()
+        # data needs time to settle :'(
+        time.sleep(1)
+
+        query_params = [
+            f'session_ids=["{session_id}"]',
+            'events=[{"id": "$pageview", "type": "events", "order": 0, "name": "$pageview"}]',
+        ]
+
+        response = self.client.get(
+            f"/api/projects/{self.team.id}/session_recordings/matching_events?{'&'.join(query_params)}&as_query=true"
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.json() == {"results": [event_id]}
+
     def test_get_matching_events(self) -> None:
         base_time = (now() - relativedelta(days=1)).replace(microsecond=0)
 
@@ -1183,12 +1181,13 @@ def test_get_matching_events(self) -> None:
         time.sleep(1)
 
         query_params = [
-            f'{SESSION_RECORDINGS_FILTER_IDS}=["{session_id}"]',
+            f'session_ids=["{session_id}"]',
             'events=[{"id": "$pageview", "type": "events", "order": 0, "name": "$pageview"}]',
         ]
 
         response = self.client.get(
-            f"/api/projects/{self.team.id}/session_recordings/matching_events?{'&'.join(query_params)}"
+            # include `as_query` since we don't want to break while deploying the code that no longer needs it
+            f"/api/projects/{self.team.id}/session_recordings/matching_events?{'&'.join(query_params)}&as_query=true"
         )
 
         assert response.status_code == status.HTTP_200_OK
diff --git a/posthog/settings/ingestion.py b/posthog/settings/ingestion.py
index 758cefd8beb3d..bb98dfd213d5d 100644
--- a/posthog/settings/ingestion.py
+++ b/posthog/settings/ingestion.py
@@ -50,12 +50,6 @@
 REPLAY_RETENTION_DAYS_MAX = get_from_env("REPLAY_RETENTION_DAYS_MAX", type_cast=int, default=90)
 
 NEW_ANALYTICS_CAPTURE_ENDPOINT = os.getenv("NEW_CAPTURE_ENDPOINT", "/i/v0/e/")
-NEW_ANALYTICS_CAPTURE_TEAM_IDS = get_set(os.getenv("NEW_ANALYTICS_CAPTURE_TEAM_IDS", ""))
 NEW_ANALYTICS_CAPTURE_EXCLUDED_TEAM_IDS = get_set(os.getenv("NEW_ANALYTICS_CAPTURE_EXCLUDED_TEAM_IDS", ""))
-NEW_ANALYTICS_CAPTURE_SAMPLING_RATE = get_from_env("NEW_ANALYTICS_CAPTURE_SAMPLING_RATE", type_cast=float, default=1.0)
 
-NEW_CAPTURE_ENDPOINTS_INCLUDED_TEAM_IDS = get_set(os.getenv("NEW_CAPTURE_ENDPOINTS_INCLUDED_TEAM_IDS", ""))
-NEW_CAPTURE_ENDPOINTS_SAMPLING_RATE = get_from_env("NEW_CAPTURE_ENDPOINTS_SAMPLING_RATE", type_cast=float, default=1.0)
-
-ELEMENT_CHAIN_AS_STRING_TEAMS = get_set(os.getenv("ELEMENT_CHAIN_AS_STRING_TEAMS", ""))
 ELEMENT_CHAIN_AS_STRING_EXCLUDED_TEAMS = get_set(os.getenv("ELEMENT_CHAIN_AS_STRING_EXCLUDED_TEAMS", ""))
diff --git a/posthog/settings/web.py b/posthog/settings/web.py
index 2c38f14937198..49c68b0adb978 100644
--- a/posthog/settings/web.py
+++ b/posthog/settings/web.py
@@ -36,13 +36,13 @@
 
 DECIDE_SKIP_POSTGRES_FLAGS = get_from_env("DECIDE_SKIP_POSTGRES_FLAGS", False, type_cast=str_to_bool)
 
+DECIDE_TOKENS_FOR_REMOTE_CONFIG = get_list(os.getenv("DECIDE_TOKENS_FOR_REMOTE_CONFIG", ""))
+
 # Decide billing analytics
 
 DECIDE_BILLING_SAMPLING_RATE = get_from_env("DECIDE_BILLING_SAMPLING_RATE", 0.1, type_cast=float)
 DECIDE_BILLING_ANALYTICS_TOKEN = get_from_env("DECIDE_BILLING_ANALYTICS_TOKEN", None, type_cast=str, optional=True)
 
-# temporary, used for safe rollout of defaulting people into anonymous events / process_persons: identified_only
-DEFAULT_IDENTIFIED_ONLY_TEAM_ID_MIN: int = get_from_env("DEFAULT_IDENTIFIED_ONLY_TEAM_ID_MIN", 1000000, type_cast=int)
 
 # Decide regular request analytics
 # Takes 3 possible formats, all separated by commas:
@@ -257,7 +257,7 @@
 LOGOUT_URL = "/logout"
 LOGIN_REDIRECT_URL = "/"
 APPEND_SLASH = False
-CORS_URLS_REGEX = r"^(/site_app/|/api/(?!early_access_features|surveys|web_experiments).*$)"
+CORS_URLS_REGEX = r"^(/site_app/|/array/|/api/(?!early_access_features|surveys|web_experiments).*$)"
 CORS_ALLOW_HEADERS = default_headers + CORS_ALLOWED_TRACING_HEADERS
 X_FRAME_OPTIONS = "SAMEORIGIN"
 
@@ -355,6 +355,7 @@
                 "^api/projects/@current/feature_flags/my_flags/?$",
                 "^/?api/projects/\\d+/query/?$",
                 "^/?api/instance_status/?$",
+                "^/array/.*$",
             ]
         ),
     )
@@ -375,7 +376,15 @@
 # Used only to display in the UI to inform users of allowlist options
 PUBLIC_EGRESS_IP_ADDRESSES = get_list(os.getenv("PUBLIC_EGRESS_IP_ADDRESSES", ""))
 
-IMPERSONATION_TIMEOUT_SECONDS = get_from_env("IMPERSONATION_TIMEOUT_SECONDS", 15 * 60, type_cast=int)
+# The total time allowed for an impersonated session
+IMPERSONATION_TIMEOUT_SECONDS = get_from_env("IMPERSONATION_TIMEOUT_SECONDS", 60 * 60 * 2, type_cast=int)
+# The time allowed for an impersonated session to be idle before it expires
+IMPERSONATION_IDLE_TIMEOUT_SECONDS = get_from_env("IMPERSONATION_IDLE_TIMEOUT_SECONDS", 30 * 60, type_cast=int)
+# Impersonation cookie last activity key
+IMPERSONATION_COOKIE_LAST_ACTIVITY_KEY = get_from_env(
+    "IMPERSONATION_COOKIE_LAST_ACTIVITY_KEY", "impersonation_last_activity"
+)
+
 SESSION_COOKIE_CREATED_AT_KEY = get_from_env("SESSION_COOKIE_CREATED_AT_KEY", "session_created_at")
 
 PROJECT_SWITCHING_TOKEN_ALLOWLIST = get_list(os.getenv("PROJECT_SWITCHING_TOKEN_ALLOWLIST", "sTMFPsFhdP1Ssg"))
@@ -389,3 +398,8 @@
 
 # disables frontend side navigation hooks to make hot-reload work seamlessly
 DEV_DISABLE_NAVIGATION_HOOKS = get_from_env("DEV_DISABLE_NAVIGATION_HOOKS", False, type_cast=bool)
+
+
+REMOTE_CONFIG_CDN_PURGE_ENDPOINT = get_from_env("REMOTE_CONFIG_CDN_PURGE_ENDPOINT", "")
+REMOTE_CONFIG_CDN_PURGE_TOKEN = get_from_env("REMOTE_CONFIG_CDN_PURGE_TOKEN", "")
+REMOTE_CONFIG_CDN_PURGE_DOMAINS = get_list(os.getenv("REMOTE_CONFIG_CDN_PURGE_DOMAINS", ""))
diff --git a/posthog/tasks/__init__.py b/posthog/tasks/__init__.py
index 08ce29e974c38..96189d7b92a9b 100644
--- a/posthog/tasks/__init__.py
+++ b/posthog/tasks/__init__.py
@@ -12,6 +12,7 @@
     integrations,
     plugin_server,
     process_scheduled_changes,
+    remote_config,
     split_person,
     sync_all_organization_available_product_features,
     sync_to_billing,
@@ -34,6 +35,7 @@
     "integrations",
     "plugin_server",
     "process_scheduled_changes",
+    "remote_config",
     "split_person",
     "sync_all_organization_available_product_features",
     "sync_to_billing",
diff --git a/posthog/tasks/alerts/checks.py b/posthog/tasks/alerts/checks.py
index 4738ca45d3ade..439305283b4cf 100644
--- a/posthog/tasks/alerts/checks.py
+++ b/posthog/tasks/alerts/checks.py
@@ -1,4 +1,3 @@
-import time
 import traceback
 
 from datetime import datetime, timedelta, UTC
@@ -25,16 +24,15 @@
     AlertState,
 )
 from posthog.utils import get_from_dict_or_attr
-from prometheus_client import Counter, Gauge
 from django.db.models import Q, F
 from collections import defaultdict
 from posthog.tasks.alerts.utils import (
     AlertEvaluationResult,
     calculation_interval_to_order,
+    next_check_time,
     send_notifications_for_breaches,
     send_notifications_for_errors,
     WRAPPER_NODE_KINDS,
-    alert_calculation_interval_to_relativedelta,
 )
 from posthog.tasks.alerts.trends import check_trends_alert
 from posthog.ph_client import ph_us_client
@@ -54,26 +52,6 @@ def __init__(self, err: Exception):
         self.__traceback__ = err.__traceback__
 
 
-HOURLY_ALERTS_BACKLOG_GAUGE = Gauge(
-    "hourly_alerts_backlog",
-    "Number of hourly alerts that are not being checked in the last hour.",
-)
-
-DAILY_ALERTS_BACKLOG_GAUGE = Gauge(
-    "daily_alerts_backlog",
-    "Number of daily alerts that are not being checked in the last 24 hours.",
-)
-
-ALERT_CHECK_ERROR_COUNTER = Counter(
-    "alerts_check_failures",
-    "Number of alert check errors that don't notify the user",
-)
-
-ALERT_COMPUTED_COUNTER = Counter(
-    "alerts_computed",
-    "Number of alerts we calculated",
-)
-
 ANIRUDH_DISTINCT_ID = "wcPbDRs08GtNzrNIXfzHvYAkwUaekW7UrAo4y3coznT"
 
 
@@ -102,8 +80,6 @@ def alerts_backlog_task() -> None:
         )
     ).count()
 
-    HOURLY_ALERTS_BACKLOG_GAUGE.set(hourly_alerts_breaching_sla)
-
     now = datetime.now(UTC)
 
     daily_alerts_breaching_sla = AlertConfiguration.objects.filter(
@@ -114,8 +90,6 @@ def alerts_backlog_task() -> None:
         )
     ).count()
 
-    DAILY_ALERTS_BACKLOG_GAUGE.set(daily_alerts_breaching_sla)
-
     with ph_us_client() as capture_ph_event:
         capture_ph_event(
             ANIRUDH_DISTINCT_ID,
@@ -135,9 +109,6 @@ def alerts_backlog_task() -> None:
             },
         )
 
-    # sleeping 30s for prometheus to pick up the metrics sent during task
-    time.sleep(30)
-
 
 @shared_task(
     ignore_result=True,
@@ -266,7 +237,6 @@ def check_alert(alert_id: str, capture_ph_event: Callable = lambda *args, **kwar
     try:
         check_alert_and_notify_atomically(alert, capture_ph_event)
     except Exception as err:
-        ALERT_CHECK_ERROR_COUNTER.inc()
         user = cast(User, alert.created_by)
 
         capture_ph_event(
@@ -309,9 +279,6 @@ def check_alert_and_notify_atomically(alert: AlertConfiguration, capture_ph_even
         so we can retry notification without re-computing insight.
     """
     set_tag("alert_config_id", alert.id)
-
-    ALERT_COMPUTED_COUNTER.inc()
-
     user = cast(User, alert.created_by)
 
     # Event to count alert checks
@@ -426,9 +393,7 @@ def add_alert_check(
 
     # IMPORTANT: update next_check_at according to interval
     # ensure we don't recheck alert until the next interval is due
-    alert.next_check_at = (alert.next_check_at or now) + alert_calculation_interval_to_relativedelta(
-        cast(AlertCalculationInterval, alert.calculation_interval)
-    )
+    alert.next_check_at = next_check_time(alert)
 
     if notify:
         alert.last_notified_at = now
diff --git a/posthog/tasks/alerts/test/test_alert_checks.py b/posthog/tasks/alerts/test/test_alert_checks.py
index 02faef2dc9bd6..17cfcce2dca79 100644
--- a/posthog/tasks/alerts/test/test_alert_checks.py
+++ b/posthog/tasks/alerts/test/test_alert_checks.py
@@ -100,7 +100,7 @@ def test_alert_is_triggered_for_values_above_higher_threshold(
         anomalies_descriptions = self.get_breach_description(mock_send_notifications_for_breaches, call_index=0)
         assert len(anomalies_descriptions) == 1
         assert (
-            "The insight value ($pageview) for previous interval (1) is more than upper threshold (0.0)"
+            "The insight value ($pageview) for current interval (1) is more than upper threshold (0.0)"
             in anomalies_descriptions[0]
         )
 
diff --git a/posthog/tasks/alerts/test/test_trends_absolute_alerts.py b/posthog/tasks/alerts/test/test_trends_absolute_alerts.py
index af4376fbe1307..1536c81885ca2 100644
--- a/posthog/tasks/alerts/test/test_trends_absolute_alerts.py
+++ b/posthog/tasks/alerts/test/test_trends_absolute_alerts.py
@@ -1,9 +1,11 @@
 from typing import Optional, Any
 from unittest.mock import ANY, MagicMock, patch
-import dateutil
-
 from freezegun import freeze_time
 
+import dateutil
+import pytz
+import datetime
+
 from posthog.models.alert import AlertCheck
 from posthog.models.instance_setting import set_instance_setting
 from posthog.tasks.alerts.checks import check_alert
@@ -15,7 +17,7 @@
     TrendsQuery,
     TrendsFilter,
     IntervalType,
-    InsightDateRange,
+    DateRange,
     BaseMathType,
     AlertState,
     AlertCalculationInterval,
@@ -24,6 +26,7 @@
 )
 from posthog.models import AlertConfiguration
 
+# 8:55 AM
 FROZEN_TIME = dateutil.parser.parse("2024-06-02T08:55:00.000Z")
 
 
@@ -40,7 +43,12 @@ def setUp(self) -> None:
         self.dashboard_api = DashboardAPI(self.client, self.team, self.assertEqual)
 
     def create_alert(
-        self, insight: dict, series_index: int, lower: Optional[int] = None, upper: Optional[int] = None
+        self,
+        insight: dict,
+        series_index: int,
+        lower: Optional[int] = None,
+        upper: Optional[int] = None,
+        calculation_interval: AlertCalculationInterval = AlertCalculationInterval.DAILY,
     ) -> dict:
         alert = self.client.post(
             f"/api/projects/{self.team.id}/alerts",
@@ -53,14 +61,16 @@ def create_alert(
                     "series_index": series_index,
                 },
                 "condition": {"type": "absolute_value"},
-                "calculation_interval": AlertCalculationInterval.DAILY,
+                "calculation_interval": calculation_interval,
                 "threshold": {"configuration": {"type": "absolute", "bounds": {"lower": lower, "upper": upper}}},
             },
         ).json()
 
         return alert
 
-    def create_time_series_trend_insight(self, breakdown: Optional[BreakdownFilter] = None) -> dict[str, Any]:
+    def create_time_series_trend_insight(
+        self, breakdown: Optional[BreakdownFilter] = None, interval: IntervalType = IntervalType.WEEK
+    ) -> dict[str, Any]:
         query_dict = TrendsQuery(
             series=[
                 EventsNode(
@@ -75,8 +85,8 @@ def create_time_series_trend_insight(self, breakdown: Optional[BreakdownFilter]
             ],
             breakdownFilter=breakdown,
             trendsFilter=TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH),
-            interval=IntervalType.WEEK,
-            dateRange=InsightDateRange(date_from="-8w"),
+            interval=interval,
+            dateRange=DateRange(date_from="-8w"),
         ).model_dump()
 
         insight = self.dashboard_api.create_insight(
@@ -104,7 +114,7 @@ def create_aggregate_trend_insight(self, breakdown: Optional[BreakdownFilter] =
             breakdownFilter=breakdown,
             trendsFilter=TrendsFilter(display=ChartDisplayType.ACTIONS_PIE),
             interval=IntervalType.WEEK,
-            dateRange=InsightDateRange(date_from="-8w"),
+            dateRange=DateRange(date_from="-8w"),
         ).model_dump()
 
         insight = self.dashboard_api.create_insight(
@@ -131,7 +141,11 @@ def test_alert_lower_threshold_breached(self, mock_send_breaches: MagicMock, moc
         assert updated_alert.state == AlertState.FIRING
         assert updated_alert.last_checked_at == FROZEN_TIME
         assert updated_alert.last_notified_at == FROZEN_TIME
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 0
@@ -165,7 +179,11 @@ def test_trend_high_threshold_breached(self, mock_send_breaches: MagicMock, mock
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 2
@@ -178,9 +196,11 @@ def test_trend_high_threshold_breached(self, mock_send_breaches: MagicMock, mock
 
     def test_trend_no_threshold_breached(self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock) -> None:
         insight = self.create_time_series_trend_insight()
-        alert = self.create_alert(insight, series_index=0, lower=0, upper=2)
+        alert = self.create_alert(
+            insight, series_index=0, lower=0, upper=2, calculation_interval=AlertCalculationInterval.MONTHLY
+        )
 
-        with freeze_time(FROZEN_TIME - dateutil.relativedelta.relativedelta(days=1)):
+        with freeze_time(FROZEN_TIME):
             _create_event(
                 team=self.team,
                 event="signed_up",
@@ -193,10 +213,49 @@ def test_trend_no_threshold_breached(self, mock_send_breaches: MagicMock, mock_s
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = datetime.datetime(2024, 7, 1, 4, 0, tzinfo=pytz.UTC)
+        # first day of next month at around 4 AM
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
-        assert alert_check.calculated_value == 1
+        assert alert_check.calculated_value == 0
+        assert alert_check.state == AlertState.NOT_FIRING
+        assert alert_check.error is None
+
+    def test_trend_no_threshold_breached_weekly(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight()
+        alert = self.create_alert(
+            insight, series_index=0, lower=0, upper=2, calculation_interval=AlertCalculationInterval.WEEKLY
+        )
+
+        with freeze_time(FROZEN_TIME):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        check_alert(alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
+        assert updated_alert.state == AlertState.NOT_FIRING
+
+        next_check = (
+            FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1, weekday=dateutil.relativedelta.MO(1))
+        ).replace(hour=3, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
+        assert alert_check.calculated_value == 0
         assert alert_check.state == AlertState.NOT_FIRING
         assert alert_check.error is None
 
@@ -231,7 +290,11 @@ def test_trend_breakdown_high_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 2
@@ -273,7 +336,11 @@ def test_trend_breakdown_low_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 1
@@ -315,7 +382,11 @@ def test_trend_breakdown_no_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value is None
@@ -355,7 +426,11 @@ def test_aggregate_trend_high_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 3
@@ -363,7 +438,7 @@ def test_aggregate_trend_high_threshold_breached(
         assert alert_check.error is None
 
         mock_send_breaches.assert_called_once_with(
-            ANY, ["The insight value (signed_up) for previous interval (3) is more than upper threshold (1.0)"]
+            ANY, ["The insight value (signed_up) for current interval (3) is more than upper threshold (1.0)"]
         )
 
     def test_aggregate_trend_with_breakdown_high_threshold_breached(
@@ -397,13 +472,187 @@ def test_aggregate_trend_with_breakdown_high_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
+        assert alert_check.calculated_value == 2
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        mock_send_breaches.assert_called_once_with(
+            ANY, ["The insight value (signed_up - Chrome) for current interval (2) is more than upper threshold (1.0)"]
+        )
+
+    def test_trend_current_interval_high_threshold_breached(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight()
+        alert = self.create_alert(insight, series_index=0, upper=1)
+
+        # around 8 AM on same day as check
+        with freeze_time(FROZEN_TIME - dateutil.relativedelta.relativedelta(hours=1)):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="2",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        check_alert(alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
+        assert alert_check.calculated_value == 2
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        mock_send_breaches.assert_called_once_with(
+            ANY, ["The insight value (signed_up) for current week (2) is more than upper threshold (1.0)"]
+        )
+
+    def test_trend_current_interval_fallback_to_previous_high_threshold_breached(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight(interval=IntervalType.DAY)
+        alert = self.create_alert(insight, series_index=0, upper=1)
+
+        # current day doesn't breach
+        with freeze_time(FROZEN_TIME - dateutil.relativedelta.relativedelta(hours=1)):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # prev day breaches
+        with freeze_time(FROZEN_TIME - dateutil.relativedelta.relativedelta(hours=26)):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="2",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        check_alert(alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 2
         assert alert_check.state == AlertState.FIRING
         assert alert_check.error is None
 
+        # should be 'previous' week as current week check should fallback
+        mock_send_breaches.assert_called_once_with(
+            ANY, ["The insight value (signed_up) for previous day (2) is more than upper threshold (1.0)"]
+        )
+
+    def test_trend_current_interval_no_threshold_breached(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight(interval=IntervalType.DAY)
+        alert = self.create_alert(insight, series_index=0, upper=1)
+
+        # day before yesterday
+        with freeze_time(
+            FROZEN_TIME - dateutil.relativedelta.relativedelta(days=2) - dateutil.relativedelta.relativedelta(hours=2)
+        ):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="2",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        check_alert(alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
+        assert updated_alert.state == AlertState.NOT_FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
+        assert alert_check.calculated_value == 0
+        assert alert_check.state == AlertState.NOT_FIRING
+        assert alert_check.error is None
+
+    def test_trend_current_interval_low_threshold_breached(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight()
+        alert = self.create_alert(insight, series_index=0, lower=2)
+
+        # around 8 AM on same day as check
+        with freeze_time(FROZEN_TIME - dateutil.relativedelta.relativedelta(hours=1)):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        check_alert(alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at is not None
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
+        # will be 0 even thought for current day it's 1
+        # it's because it's absolute alert and lower threshold
+        # so current day isn't checked, it directly checks previous day
+        assert alert_check.calculated_value == 0
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
         mock_send_breaches.assert_called_once_with(
-            ANY, ["The insight value (signed_up - Chrome) for previous interval (2) is more than upper threshold (1.0)"]
+            ANY, ["The insight value (signed_up) for previous week (0) is less than lower threshold (2.0)"]
         )
diff --git a/posthog/tasks/alerts/test/test_trends_relative_alerts.py b/posthog/tasks/alerts/test/test_trends_relative_alerts.py
index de530d3817fd7..8de118c8cce5e 100644
--- a/posthog/tasks/alerts/test/test_trends_relative_alerts.py
+++ b/posthog/tasks/alerts/test/test_trends_relative_alerts.py
@@ -1,10 +1,10 @@
 from typing import Optional, Any
 from unittest.mock import ANY, call, MagicMock, patch
-import dateutil
-
+from freezegun import freeze_time
 
+import dateutil
 import dateutil.relativedelta
-from freezegun import freeze_time
+import pytz
 
 from posthog.models.alert import AlertCheck
 from posthog.models.instance_setting import set_instance_setting
@@ -17,7 +17,7 @@
     TrendsQuery,
     TrendsFilter,
     IntervalType,
-    InsightDateRange,
+    DateRange,
     BaseMathType,
     AlertState,
     AlertCalculationInterval,
@@ -89,7 +89,7 @@ def create_time_series_trend_insight(
             breakdownFilter=breakdown,
             trendsFilter=TrendsFilter(display=ChartDisplayType.ACTIONS_LINE_GRAPH),
             interval=interval,
-            dateRange=InsightDateRange(date_from="-8w"),
+            dateRange=DateRange(date_from="-8w"),
         ).model_dump()
 
         insight = self.dashboard_api.create_insight(
@@ -123,7 +123,11 @@ def test_alert_properties(self, mock_send_breaches: MagicMock, mock_send_errors:
         assert updated_alert.state == AlertState.FIRING
         assert updated_alert.last_checked_at == FROZEN_TIME
         assert updated_alert.last_notified_at == FROZEN_TIME
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 0
@@ -168,7 +172,11 @@ def test_relative_increase_absolute_upper_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=alert["id"]).latest("created_at")
 
@@ -199,7 +207,7 @@ def test_relative_increase_upper_threshold_breached(
             insight,
             series_index=0,
             condition_type=AlertConditionType.RELATIVE_INCREASE,
-            threshold_type=InsightThresholdType.ABSOLUTE,
+            threshold_type=InsightThresholdType.PERCENTAGE,
             upper=0.2,
         )
 
@@ -247,7 +255,11 @@ def test_relative_increase_upper_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -259,7 +271,11 @@ def test_relative_increase_upper_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -329,7 +345,11 @@ def test_relative_increase_lower_threshold_breached_1(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -346,7 +366,11 @@ def test_relative_increase_lower_threshold_breached_1(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -421,7 +445,11 @@ def test_relative_increase_lower_threshold_breached_2(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -433,7 +461,11 @@ def test_relative_increase_lower_threshold_breached_2(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -508,7 +540,11 @@ def test_relative_decrease_upper_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -524,7 +560,11 @@ def test_relative_decrease_upper_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -598,7 +638,11 @@ def test_relative_decrease_lower_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -614,7 +658,11 @@ def test_relative_decrease_lower_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -694,7 +742,11 @@ def test_relative_increase_no_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 2
@@ -705,7 +757,11 @@ def test_relative_increase_no_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 2
@@ -779,7 +835,11 @@ def test_relative_decrease_no_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
         assert alert_check.calculated_value == 2
@@ -790,7 +850,11 @@ def test_relative_decrease_no_threshold_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
         assert alert_check.calculated_value == (2 / 3)
@@ -878,7 +942,11 @@ def test_breakdown_relative_increase_upper_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -890,7 +958,11 @@ def test_breakdown_relative_increase_upper_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -996,7 +1068,11 @@ def test_breakdown_relative_increase_lower_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -1008,7 +1084,11 @@ def test_breakdown_relative_increase_lower_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -1114,7 +1194,11 @@ def test_breakdown_relative_decrease_lower_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -1126,7 +1210,11 @@ def test_breakdown_relative_decrease_lower_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -1233,7 +1321,11 @@ def test_breakdown_relative_decrease_upper_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -1245,7 +1337,11 @@ def test_breakdown_relative_decrease_upper_breached(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -1340,7 +1436,11 @@ def test_breakdown_relative_decrease_no_breaches(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -1352,7 +1452,11 @@ def test_breakdown_relative_decrease_no_breaches(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -1432,7 +1536,11 @@ def test_breakdown_relative_increase_no_breaches(
 
         updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
 
@@ -1444,7 +1552,11 @@ def test_breakdown_relative_increase_no_breaches(
 
         updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
         assert updated_alert.state == AlertState.NOT_FIRING
-        assert updated_alert.next_check_at == FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
 
         alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
 
@@ -1453,3 +1565,409 @@ def test_breakdown_relative_increase_no_breaches(
         assert alert_check.error is None
 
         mock_send_breaches.assert_not_called()
+
+    def test_current_interval_relative_increase_upper_threshold_breached(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight(interval=IntervalType.WEEK)
+
+        # alert if sign ups increase by more than 1
+        absolute_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_INCREASE,
+            threshold_type=InsightThresholdType.ABSOLUTE,
+            upper=1,
+        )
+
+        # alert if sign ups increase by more than 20%
+        percentage_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_INCREASE,
+            threshold_type=InsightThresholdType.PERCENTAGE,
+            upper=0.2,
+        )
+
+        # FROZEN_TIME is on Tue, insight has weekly interval
+        # we aggregate our weekly insight numbers to display for Sun (19th May, 26th May, 2nd June)
+
+        # set current interval to have 3 events
+        with freeze_time(FROZEN_TIME):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="2",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="3",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="4",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # set previous interval (last week) to have 1 event
+        last_tue = FROZEN_TIME - dateutil.relativedelta.relativedelta(weeks=1)
+
+        with freeze_time(last_tue):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # set previous to previous interval (last to last week) to also have 1 event
+        # so event shouldn't fire for the previous week
+        last_to_last_tue = FROZEN_TIME - dateutil.relativedelta.relativedelta(weeks=2)
+
+        with freeze_time(last_to_last_tue):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # alert should fire as we had *increase* in events of (2 or 200%) week over week
+        check_alert(absolute_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == 2
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        mock_send_breaches.assert_called_once_with(
+            ANY, ["The insight value (signed_up) for current week (2) increased more than upper threshold (1.0)"]
+        )
+
+        check_alert(percentage_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == 2
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        mock_send_breaches.assert_called_with(
+            ANY,
+            ["The insight value (signed_up) for current week (200.00%) increased more than upper threshold (20.00%)"],
+        )
+
+    def test_current_interval_relative_increase_fallback_upper_threshold_breached(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight(interval=IntervalType.WEEK)
+
+        # alert if sign ups increase by more than 1
+        absolute_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_INCREASE,
+            threshold_type=InsightThresholdType.ABSOLUTE,
+            upper=1,
+        )
+
+        # alert if sign ups increase by more than 20%
+        percentage_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_INCREASE,
+            threshold_type=InsightThresholdType.PERCENTAGE,
+            upper=0.2,
+        )
+
+        # FROZEN_TIME is on Tue, insight has weekly interval
+        # we aggregate our weekly insight numbers to display for Sun (19th May, 26th May, 2nd June)
+
+        # set current interval to have 1 events
+        with freeze_time(FROZEN_TIME):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="2",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # set previous interval (last week) to have 3 events
+        last_tue = FROZEN_TIME - dateutil.relativedelta.relativedelta(weeks=1)
+
+        with freeze_time(last_tue):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="3",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="4",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # set previous to previous interval (last to last week) to also have 1 event
+        # so event shouldn't fire for the previous week
+        last_to_last_tue = FROZEN_TIME - dateutil.relativedelta.relativedelta(weeks=2)
+
+        with freeze_time(last_to_last_tue):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # alert should fire as we had *increase* in events of (2 or 200%) week over week
+        check_alert(absolute_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == 2
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        # should be 'previous' week as we haven't breached for current week
+        # so logic fallback to previous week
+        mock_send_breaches.assert_called_once_with(
+            ANY, ["The insight value (signed_up) for previous week (2) increased more than upper threshold (1.0)"]
+        )
+
+        check_alert(percentage_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == 2
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        mock_send_breaches.assert_called_with(
+            ANY,
+            ["The insight value (signed_up) for previous week (200.00%) increased more than upper threshold (20.00%)"],
+        )
+
+    def test_relative_increase_when_previous_value_is_0(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight(interval=IntervalType.WEEK)
+
+        # alert if sign ups increase by more than 1
+        absolute_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_INCREASE,
+            threshold_type=InsightThresholdType.ABSOLUTE,
+            upper=1,
+        )
+
+        # alert if sign ups increase by more than 20%
+        percentage_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_INCREASE,
+            threshold_type=InsightThresholdType.PERCENTAGE,
+            upper=0.2,
+        )
+
+        # FROZEN_TIME is on Tue, insight has weekly interval
+        # we aggregate our weekly insight numbers to display for Sun (19th May, 26th May, 2nd June)
+
+        # set previous interval (last week) to have 2 events
+        last_tue = FROZEN_TIME - dateutil.relativedelta.relativedelta(weeks=1)
+
+        with freeze_time(last_tue):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="3",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # set previous to previous interval (last to last week) to have 0 events
+
+        # alert should fire as we had *increase* in events of (infinity) week over week
+        check_alert(absolute_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == 2
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        # should be 'previous' week as we haven't breached for current week
+        # so logic fallback to previous week
+        mock_send_breaches.assert_called_once_with(
+            ANY, ["The insight value (signed_up) for previous week (2) increased more than upper threshold (1.0)"]
+        )
+
+        check_alert(percentage_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == float("inf")
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        mock_send_breaches.assert_called_with(
+            ANY,
+            ["The insight value (signed_up) for previous week (inf%) increased more than upper threshold (20.00%)"],
+        )
+
+    def test_relative_decrease_when_previous_value_is_0(
+        self, mock_send_breaches: MagicMock, mock_send_errors: MagicMock
+    ) -> None:
+        insight = self.create_time_series_trend_insight(interval=IntervalType.WEEK)
+
+        # alert if sign ups decreases by more than 1
+        absolute_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_DECREASE,
+            threshold_type=InsightThresholdType.ABSOLUTE,
+            upper=1,
+        )
+
+        # alert if sign ups decreases by more than 20%
+        percentage_alert = self.create_alert(
+            insight,
+            series_index=0,
+            condition_type=AlertConditionType.RELATIVE_DECREASE,
+            threshold_type=InsightThresholdType.PERCENTAGE,
+            upper=0.2,
+        )
+
+        # FROZEN_TIME is on Tue, insight has weekly interval
+        # we aggregate our weekly insight numbers to display for Sun (19th May, 26th May, 2nd June)
+
+        # set previous interval (last week) to have 2 events
+        last_tue = FROZEN_TIME - dateutil.relativedelta.relativedelta(weeks=1)
+
+        with freeze_time(last_tue):
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="1",
+                properties={"$browser": "Chrome"},
+            )
+            _create_event(
+                team=self.team,
+                event="signed_up",
+                distinct_id="3",
+                properties={"$browser": "Chrome"},
+            )
+            flush_persons_and_events()
+
+        # set previous to previous interval (last to last week) to have 0 events
+
+        # alert should fire as we had *decrease* in events of (infinity) week over week
+        check_alert(absolute_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=absolute_alert["id"])
+        assert updated_alert.state == AlertState.NOT_FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=absolute_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == -2
+        assert alert_check.state == AlertState.NOT_FIRING
+        assert alert_check.error is None
+
+        check_alert(percentage_alert["id"])
+
+        updated_alert = AlertConfiguration.objects.get(pk=percentage_alert["id"])
+        assert updated_alert.state == AlertState.FIRING
+
+        next_check = (FROZEN_TIME + dateutil.relativedelta.relativedelta(days=1)).replace(hour=1, tzinfo=pytz.UTC)
+        assert updated_alert.next_check_at
+        assert updated_alert.next_check_at.hour == next_check.hour
+        assert updated_alert.next_check_at.date() == next_check.date()
+
+        alert_check = AlertCheck.objects.filter(alert_configuration=percentage_alert["id"]).latest("created_at")
+
+        assert alert_check.calculated_value == float("inf")
+        assert alert_check.state == AlertState.FIRING
+        assert alert_check.error is None
+
+        mock_send_breaches.assert_called_with(
+            ANY,
+            ["The insight value (signed_up) for previous week (inf%) decreased more than upper threshold (20.00%)"],
+        )
diff --git a/posthog/tasks/alerts/trends.py b/posthog/tasks/alerts/trends.py
index 0a744b4ebdf3c..0175d414498d4 100644
--- a/posthog/tasks/alerts/trends.py
+++ b/posthog/tasks/alerts/trends.py
@@ -43,6 +43,17 @@ class TrendResult(TypedDict):
 
 
 def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: TrendsQuery) -> AlertEvaluationResult:
+    """
+    Calculates insight value for the needed time periods and compares it with the threshold.
+
+    Generally we check the insight value for the previous interval (day/week... grouping set on the trend insight) and compare it with the threshold/value for interval before that.
+    This is done because we need the current interval to complete before comparing against threshold.
+    (eg. if needing to check value < X, need to wait as more events will come in before interval finishes)
+
+    But in some cases (when check_current_interval = True) like value > X or value inc > X, we can check the value for the current interval and alert right away if threshold is breached.
+    So then we check current interval value first and alert if threshold breached, otherwise fallback and process previous interval.
+    """
+
     if "type" in alert.config and alert.config["type"] == "TrendsAlertConfig":
         config = TrendsAlertConfig.model_validate(alert.config)
     else:
@@ -51,14 +62,14 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
     condition = AlertCondition.model_validate(alert.condition)
     threshold = InsightThreshold.model_validate(alert.threshold.configuration) if alert.threshold else None
 
-    if not threshold:
+    if not threshold or not threshold.bounds:
         return AlertEvaluationResult(value=0, breaches=[])
 
     has_breakdown = query.breakdownFilter and (
         (query.breakdownFilter.breakdown and query.breakdownFilter.breakdown_type) or query.breakdownFilter.breakdowns
     )
-
     is_non_time_series = _is_non_time_series_trend(query)
+    check_current_interval = False
 
     match condition.type:
         case AlertConditionType.ABSOLUTE_VALUE:
@@ -87,14 +98,32 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
 
             interval = query.interval if not is_non_time_series else None
 
+            if threshold.bounds.upper is not None:
+                # checking for value > X so we can also check current interval value
+                check_current_interval = True
+
             if has_breakdown:
                 # for breakdowns, we need to check all values in calculation_result.result
                 breakdown_results = calculation_result.result
 
                 for breakdown_result in breakdown_results:
-                    # pick previous interval value
+                    if check_current_interval:
+                        current_interval_value = _pick_interval_value_from_trend_result(query, breakdown_result, 0)
+                        breaches = _breach_messages(
+                            bounds=threshold.bounds,
+                            calculated_value=current_interval_value,
+                            threshold_type=threshold.type,
+                            condition_type=condition.type,
+                            interval_type=interval,
+                            series=breakdown_result["label"],
+                            is_current_interval=True,
+                        )
+                        if breaches:
+                            return AlertEvaluationResult(value=current_interval_value, breaches=breaches)
+
+                    # fall back to check previous interval
                     prev_interval_value = _pick_interval_value_from_trend_result(query, breakdown_result, -1)
-                    breaches = _validate_bounds(
+                    breaches = _breach_messages(
                         threshold.bounds,
                         prev_interval_value,
                         threshold.type,
@@ -102,7 +131,6 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
                         interval,
                         breakdown_result["label"],
                     )
-
                     if breaches:
                         # found one breakdown value that breached the threshold
                         return AlertEvaluationResult(value=prev_interval_value, breaches=breaches)
@@ -113,8 +141,24 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
                 # for non breakdowns, we pick the series (config.series_index) from calculation_result.result
                 selected_series_result = _pick_series_result(config, calculation_result)
 
+                if check_current_interval:
+                    # pick current interval value
+                    current_interval_value = _pick_interval_value_from_trend_result(query, selected_series_result, 0)
+                    breaches = _breach_messages(
+                        threshold.bounds,
+                        current_interval_value,
+                        threshold.type,
+                        condition.type,
+                        interval,
+                        selected_series_result["label"],
+                        is_current_interval=True,
+                    )
+                    if breaches:
+                        return AlertEvaluationResult(value=current_interval_value, breaches=breaches)
+
+                # fall back to check previous interval
                 prev_interval_value = _pick_interval_value_from_trend_result(query, selected_series_result, -1)
-                breaches = _validate_bounds(
+                breaches = _breach_messages(
                     threshold.bounds,
                     prev_interval_value,
                     threshold.type,
@@ -133,7 +177,6 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
             # so we need to compute the trend values for last 3 intervals
             # and then compare the previous interval with value for the interval before previous
             filters_overrides = _date_range_override_for_intervals(query, last_x_intervals=3)
-
             calculation_result = calculate_for_query_based_insight(
                 insight,
                 team=alert.team,
@@ -142,55 +185,93 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
                 filters_override=filters_overrides,
             )
 
-            results_to_evaluate = []
+            results_to_evaluate: list[TrendResult] = []
 
             if has_breakdown:
                 # for breakdowns, we need to check all values in calculation_result.result
-                breakdown_results = calculation_result.result
+                breakdown_results = cast(list[TrendResult], calculation_result.result)
                 results_to_evaluate.extend(breakdown_results)
             else:
                 # for non breakdowns, we pick the series (config.series_index) from calculation_result.result
                 selected_series_result = _pick_series_result(config, calculation_result)
                 results_to_evaluate.append(selected_series_result)
 
+            if not results_to_evaluate:
+                raise RuntimeError(f"No results found for insight with alert id = {alert.id}")
+
             # if we don't have breakdown, we'll have to evaluate just one result
             # and increase will be the evaluated value of that result
             increase = None
+            breaches = []
+
+            if threshold.bounds.upper is not None:
+                # checking for value increased > X so we can also check current interval value
+                # as can alert right away if current interval value - previous interval value > upper threshold
+                check_current_interval = True
 
             for result in results_to_evaluate:
+                current_interval_value = _pick_interval_value_from_trend_result(query, result, 0)
                 prev_interval_value = _pick_interval_value_from_trend_result(query, result, -1)
                 prev_prev_interval_value = _pick_interval_value_from_trend_result(query, result, -2)
 
-                if threshold.type == InsightThresholdType.ABSOLUTE:
-                    increase = prev_interval_value - prev_prev_interval_value
-                    breaches = _validate_bounds(
+                if check_current_interval:
+                    if threshold.type == InsightThresholdType.ABSOLUTE:
+                        increase = current_interval_value - prev_interval_value
+                    elif threshold.type == InsightThresholdType.PERCENTAGE:
+                        if prev_interval_value == 0 and current_interval_value == 0:
+                            increase = 0
+                        elif prev_interval_value == 0:
+                            increase = float("inf")
+                        else:
+                            increase = (current_interval_value - prev_interval_value) / prev_interval_value
+                    else:
+                        raise ValueError(
+                            f"Neither relative nor absolute threshold configured for alert condition RELATIVE_INCREASE"
+                        )
+
+                    breaches = _breach_messages(
                         threshold.bounds,
                         increase,
                         threshold.type,
                         condition.type,
                         query.interval,
                         result["label"],
+                        is_current_interval=True,
                     )
+
+                    if breaches:
+                        # found a breach for one of the results so alert
+                        return AlertEvaluationResult(value=increase, breaches=breaches)
+
+                # fallback to check previous intervals
+                if threshold.type == InsightThresholdType.ABSOLUTE:
+                    increase = prev_interval_value - prev_prev_interval_value
                 elif threshold.type == InsightThresholdType.PERCENTAGE:
-                    increase = (prev_interval_value - prev_prev_interval_value) / prev_prev_interval_value
-                    breaches = _validate_bounds(
-                        threshold.bounds,
-                        increase,
-                        threshold.type,
-                        condition.type,
-                        query.interval,
-                        result["label"],
-                    )
+                    if prev_prev_interval_value == 0 and prev_interval_value == 0:
+                        increase = 0
+                    elif prev_prev_interval_value == 0:
+                        increase = float("inf")
+                    else:
+                        increase = (prev_interval_value - prev_prev_interval_value) / prev_prev_interval_value
                 else:
                     raise ValueError(
                         f"Neither relative nor absolute threshold configured for alert condition RELATIVE_INCREASE"
                     )
 
+                breaches = _breach_messages(
+                    threshold.bounds,
+                    increase,
+                    threshold.type,
+                    condition.type,
+                    query.interval,
+                    result["label"],
+                )
+
                 if breaches:
                     # found a breach for one of the results so alert
                     return AlertEvaluationResult(value=increase, breaches=breaches)
 
-            return AlertEvaluationResult(value=(increase if not has_breakdown else None), breaches=breaches)
+            return AlertEvaluationResult(value=(increase if not has_breakdown else None), breaches=[])
 
         case AlertConditionType.RELATIVE_DECREASE:
             if is_non_time_series:
@@ -201,7 +282,6 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
             # so we need to compute the trend values for last 3 intervals
             # and then compare the previous interval with value for the interval before previous
             filters_overrides = _date_range_override_for_intervals(query, last_x_intervals=3)
-
             calculation_result = calculate_for_query_based_insight(
                 insight,
                 team=alert.team,
@@ -234,34 +314,32 @@ def check_trends_alert(alert: AlertConfiguration, insight: Insight, query: Trend
 
                 if threshold.type == InsightThresholdType.ABSOLUTE:
                     decrease = prev_prev_interval_value - prev_interval_value
-                    breaches = _validate_bounds(
-                        threshold.bounds,
-                        decrease,
-                        threshold.type,
-                        condition.type,
-                        query.interval,
-                        result["label"],
-                    )
                 elif threshold.type == InsightThresholdType.PERCENTAGE:
-                    decrease = (prev_prev_interval_value - prev_interval_value) / prev_prev_interval_value
-                    breaches = _validate_bounds(
-                        threshold.bounds,
-                        decrease,
-                        threshold.type,
-                        condition.type,
-                        query.interval,
-                        result["label"],
-                    )
+                    if prev_prev_interval_value == 0 and prev_interval_value == 0:
+                        decrease = 0
+                    elif prev_prev_interval_value == 0:
+                        decrease = float("inf")
+                    else:
+                        decrease = (prev_prev_interval_value - prev_interval_value) / prev_prev_interval_value
                 else:
                     raise ValueError(
                         f"Neither relative nor absolute threshold configured for alert condition RELATIVE_INCREASE"
                     )
 
+                breaches = _breach_messages(
+                    threshold.bounds,
+                    decrease,
+                    threshold.type,
+                    condition.type,
+                    query.interval,
+                    result["label"],
+                )
+
                 if breaches:
                     # found a breach for one of the results so alert
                     return AlertEvaluationResult(value=decrease, breaches=breaches)
 
-            return AlertEvaluationResult(value=(decrease if not has_breakdown else None), breaches=breaches)
+            return AlertEvaluationResult(value=(decrease if not has_breakdown else None), breaches=[])
 
         case _:
             raise NotImplementedError(f"Unsupported alert condition type: {condition.type}")
@@ -314,19 +392,16 @@ def _pick_interval_value_from_trend_result(query: TrendsQuery, result: TrendResu
     return data[index_from_back]
 
 
-def _validate_bounds(
-    bounds: InsightsThresholdBounds | None,
+def _breach_messages(
+    bounds: InsightsThresholdBounds,
     calculated_value: float,
     threshold_type: InsightThresholdType,
     condition_type: AlertConditionType,
     interval_type: IntervalType | None,
     series: str,
+    is_current_interval: bool = False,
 ) -> list[str]:
-    if not bounds:
-        return []
-
     is_percentage = threshold_type == InsightThresholdType.PERCENTAGE
-
     formatted_value = f"{calculated_value:.2%}" if is_percentage else calculated_value
 
     match condition_type:
@@ -340,12 +415,13 @@ def _validate_bounds(
     if bounds.lower is not None and calculated_value < bounds.lower:
         lower_value = f"{bounds.lower:.2%}" if is_percentage else bounds.lower
         return [
-            f"The insight value ({series}) for previous {interval_type or 'interval'} ({formatted_value}) {condition_text} less than lower threshold ({lower_value})"
+            f"The insight value ({series}) for {'current' if is_current_interval else 'previous'} {interval_type or 'interval'} ({formatted_value}) {condition_text} less than lower threshold ({lower_value})"
         ]
+
     if bounds.upper is not None and calculated_value > bounds.upper:
         upper_value = f"{bounds.upper:.2%}" if is_percentage else bounds.upper
         return [
-            f"The insight value ({series}) for previous {interval_type or 'interval'} ({formatted_value}) {condition_text} more than upper threshold ({upper_value})"
+            f"The insight value ({series}) for {'current' if is_current_interval else 'previous'} {interval_type or 'interval'} ({formatted_value}) {condition_text} more than upper threshold ({upper_value})"
         ]
 
     return []
diff --git a/posthog/tasks/alerts/utils.py b/posthog/tasks/alerts/utils.py
index 686ec8a1355fe..28bebd0aa43e3 100644
--- a/posthog/tasks/alerts/utils.py
+++ b/posthog/tasks/alerts/utils.py
@@ -1,6 +1,8 @@
-from dateutil.relativedelta import relativedelta
-
+from dateutil.relativedelta import relativedelta, MO
 from django.utils import timezone
+import pytz
+
+from datetime import datetime
 import structlog
 
 from posthog.email import EmailMessage
@@ -56,6 +58,51 @@ def alert_calculation_interval_to_relativedelta(alert_calculation_interval: Aler
             raise ValueError(f"Invalid alert calculation interval: {alert_calculation_interval}")
 
 
+def next_check_time(alert: AlertConfiguration) -> datetime:
+    """
+    Rule by calculation interval
+
+    hourly alerts -> want them to run at the same min every hour (same min comes from creation time so that they're spread out and don't all run at the start of the hour)
+    daily alerts -> want them to run at the start of the day (around 1am) by the timezone of the team
+    weekly alerts -> want them to run at the start of the week (Mon around 3am) by the timezone of the team
+    monthly alerts -> want them to run at the start of the month (first day of the month around 4am) by the timezone of the team
+    """
+    now = datetime.now(pytz.UTC)
+    team_timezone = pytz.timezone(alert.team.timezone)
+
+    match alert.calculation_interval:
+        case AlertCalculationInterval.HOURLY:
+            return (alert.next_check_at or now) + relativedelta(hours=1)
+        case AlertCalculationInterval.DAILY:
+            # Get the next date in the specified timezone
+            tomorrow_local = datetime.now(team_timezone) + relativedelta(days=1)
+
+            # set hour to 1 AM
+            # only replacing hour and not minute/second... to distribute execution of all daily alerts
+            one_am_local = tomorrow_local.replace(hour=1)
+
+            # Convert to UTC
+            return one_am_local.astimezone(pytz.utc)
+        case AlertCalculationInterval.WEEKLY:
+            next_monday_local = datetime.now(team_timezone) + relativedelta(days=1, weekday=MO(1))
+
+            # Set the hour to around 3 AM on next Monday
+            next_monday_1am_local = next_monday_local.replace(hour=3)
+
+            # Convert to UTC
+            return next_monday_1am_local.astimezone(pytz.utc)
+        case AlertCalculationInterval.MONTHLY:
+            next_month_local = datetime.now(team_timezone) + relativedelta(months=1)
+
+            # Set hour to 4 AM on first day of next month
+            next_month_1am_local = next_month_local.replace(day=1, hour=4)
+
+            # Convert to UTC
+            return next_month_1am_local.astimezone(pytz.utc)
+        case _:
+            raise ValueError(f"Invalid alert calculation interval: {alert.calculation_interval}")
+
+
 def send_notifications_for_breaches(alert: AlertConfiguration, breaches: list[str]) -> None:
     subject = f"PostHog alert {alert.name} is firing"
     campaign_key = f"alert-firing-notification-{alert.id}-{timezone.now().timestamp()}"
diff --git a/posthog/tasks/calculate_cohort.py b/posthog/tasks/calculate_cohort.py
index 53bc65d9abef6..be28173b5000f 100644
--- a/posthog/tasks/calculate_cohort.py
+++ b/posthog/tasks/calculate_cohort.py
@@ -1,20 +1,23 @@
 import time
 from typing import Any, Optional
 
+from django.conf import settings
+
+from posthog.models.team.team import Team
 import structlog
 from celery import shared_task
 from dateutil.relativedelta import relativedelta
 from django.db.models import F, ExpressionWrapper, DurationField, Q
 from django.utils import timezone
 from prometheus_client import Gauge
-from sentry_sdk import set_tag
+from sentry_sdk import capture_exception, set_tag
 
 from datetime import timedelta
 
 from posthog.api.monitoring import Feature
 from posthog.models import Cohort
 from posthog.models.cohort import get_and_update_pending_version
-from posthog.models.cohort.util import clear_stale_cohortpeople
+from posthog.models.cohort.util import clear_stale_cohortpeople, get_static_cohort_size
 from posthog.models.user import User
 
 COHORT_RECALCULATIONS_BACKLOG_GAUGE = Gauge(
@@ -109,37 +112,65 @@ def calculate_cohort_ch(cohort_id: int, pending_version: int, initiating_user_id
 
 
 @shared_task(ignore_result=True, max_retries=1)
-def calculate_cohort_from_list(cohort_id: int, items: list[str]) -> None:
+def calculate_cohort_from_list(cohort_id: int, items: list[str], team_id: Optional[int] = None) -> None:
+    """
+    team_id is only optional for backwards compatibility with the old celery task signature.
+    All new tasks should pass team_id explicitly.
+    """
     start_time = time.time()
     cohort = Cohort.objects.get(pk=cohort_id)
+    if team_id is None:
+        team_id = cohort.team_id
 
-    cohort.insert_users_by_list(items)
+    cohort.insert_users_by_list(items, team_id=team_id)
     logger.warn("Calculating cohort {} from CSV took {:.2f} seconds".format(cohort.pk, (time.time() - start_time)))
 
 
 @shared_task(ignore_result=True, max_retries=1)
-def insert_cohort_from_insight_filter(cohort_id: int, filter_data: dict[str, Any]) -> None:
-    from posthog.api.cohort import (
-        insert_cohort_actors_into_ch,
-        insert_cohort_people_into_pg,
-    )
+def insert_cohort_from_insight_filter(
+    cohort_id: int, filter_data: dict[str, Any], team_id: Optional[int] = None
+) -> None:
+    """
+    team_id is only optional for backwards compatibility with the old celery task signature.
+    All new tasks should pass team_id explicitly.
+    """
+    from posthog.api.cohort import insert_cohort_actors_into_ch, insert_cohort_people_into_pg
 
     cohort = Cohort.objects.get(pk=cohort_id)
+    if team_id is None:
+        team_id = cohort.team_id
 
-    insert_cohort_actors_into_ch(cohort, filter_data)
-    insert_cohort_people_into_pg(cohort=cohort)
+    insert_cohort_actors_into_ch(cohort, filter_data, team_id=team_id)
+    insert_cohort_people_into_pg(cohort, team_id=team_id)
 
 
 @shared_task(ignore_result=True, max_retries=1)
-def insert_cohort_from_query(cohort_id: int) -> None:
-    from posthog.api.cohort import (
-        insert_cohort_people_into_pg,
-        insert_cohort_query_actors_into_ch,
-    )
+def insert_cohort_from_query(cohort_id: int, team_id: Optional[int] = None) -> None:
+    """
+    team_id is only optional for backwards compatibility with the old celery task signature.
+    All new tasks should pass team_id explicitly.
+    """
+    from posthog.api.cohort import insert_cohort_people_into_pg, insert_cohort_query_actors_into_ch
 
     cohort = Cohort.objects.get(pk=cohort_id)
-    insert_cohort_query_actors_into_ch(cohort)
-    insert_cohort_people_into_pg(cohort=cohort)
+    if team_id is None:
+        team_id = cohort.team_id
+    team = Team.objects.get(pk=team_id)
+    try:
+        insert_cohort_query_actors_into_ch(cohort, team=team)
+        insert_cohort_people_into_pg(cohort, team_id=team_id)
+        cohort.count = get_static_cohort_size(cohort_id=cohort.id, team_id=cohort.team_id)
+        cohort.errors_calculating = 0
+        cohort.last_calculation = timezone.now()
+    except:
+        cohort.errors_calculating = F("errors_calculating") + 1
+        cohort.last_error_at = timezone.now()
+        capture_exception()
+        if settings.DEBUG:
+            raise
+    finally:
+        cohort.is_calculating = False
+        cohort.save()
 
 
 @shared_task(ignore_result=True, max_retries=1)
diff --git a/posthog/tasks/exports/csv_exporter.py b/posthog/tasks/exports/csv_exporter.py
index 751b8f5db70cc..7657db26c203f 100644
--- a/posthog/tasks/exports/csv_exporter.py
+++ b/posthog/tasks/exports/csv_exporter.py
@@ -170,19 +170,21 @@ def _convert_response_to_csv_data(data: Any) -> Generator[Any, None, None]:
                 yield line
             return
         elif isinstance(first_result.get("data"), list):
+            is_comparison = first_result.get("compare_label")
+
+            # take date labels from current results, when comparing against previous
+            # as previous results will be indexed with offset
+            date_labels_item = next((x for x in results if x.get("compare_label") == "current"), None)
+
             # TRENDS LIKE
             for index, item in enumerate(results):
                 label = item.get("label", f"Series #{index + 1}")
                 compare_label = item.get("compare_label", "")
                 series_name = f"{label} - {compare_label}" if compare_label else label
-                line = {"series": series_name}
 
-                # take labels from current results, when comparing against previous
-                if item.get("compare_label") == "previous":
-                    label_item = results[index - 1]
-                else:
-                    label_item = item
+                line = {"series": series_name}
 
+                label_item = date_labels_item if is_comparison else item
                 action = item.get("action")
 
                 if isinstance(action, dict) and action.get("custom_name"):
diff --git a/posthog/tasks/exports/test/test_csv_exporter.py b/posthog/tasks/exports/test/test_csv_exporter.py
index 29b57da6d7a0b..4d53742ed65bb 100644
--- a/posthog/tasks/exports/test/test_csv_exporter.py
+++ b/posthog/tasks/exports/test/test_csv_exporter.py
@@ -2,13 +2,13 @@
 from typing import Any, Optional
 from unittest import mock
 from unittest.mock import MagicMock, Mock, patch, ANY
+from dateutil.relativedelta import relativedelta
 
 from openpyxl import load_workbook
 from io import BytesIO
 import pytest
 from boto3 import resource
 from botocore.client import Config
-from dateutil.relativedelta import relativedelta
 from django.test import override_settings
 from django.utils.timezone import now
 from requests.exceptions import HTTPError
@@ -703,23 +703,75 @@ def test_csv_exporter_trends_query_with_compare_previous_option(
         self,
     ) -> None:
         _create_person(distinct_ids=[f"user_1"], team=self.team)
-        events_by_person = {
-            "user_1": [
-                {
-                    "event": "$pageview",
-                    "timestamp": datetime(2023, 3, 21, 13, 46),
-                },
-                {
-                    "event": "$pageview",
-                    "timestamp": datetime(2023, 3, 21, 13, 46),
-                },
-                {
-                    "event": "$pageview",
-                    "timestamp": datetime(2023, 3, 22, 13, 47),
-                },
-            ],
-        }
-        journeys_for(events_by_person, self.team)
+
+        date = datetime(2023, 3, 21, 13, 46)
+        date_next_week = date + relativedelta(days=7)
+
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date,
+            properties={"$browser": "Safari"},
+        )
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date,
+            properties={"$browser": "Chrome"},
+        )
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date,
+            properties={"$browser": "Chrome"},
+        )
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date,
+            properties={"$browser": "Firefox"},
+        )
+
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date_next_week,
+            properties={"$browser": "Chrome"},
+        )
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date_next_week,
+            properties={"$browser": "Chrome"},
+        )
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date_next_week,
+            properties={"$browser": "Chrome"},
+        )
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date_next_week,
+            properties={"$browser": "Firefox"},
+        )
+        _create_event(
+            event="$pageview",
+            distinct_id="1",
+            team=self.team,
+            timestamp=date_next_week,
+            properties={"$browser": "Firefox"},
+        )
+
         flush_persons_and_events()
 
         exported_asset = ExportedAsset(
@@ -728,7 +780,10 @@ def test_csv_exporter_trends_query_with_compare_previous_option(
             export_context={
                 "source": {
                     "kind": "TrendsQuery",
-                    "dateRange": {"date_to": "2023-03-22", "date_from": "2023-03-22"},
+                    "dateRange": {
+                        "date_from": date.strftime("%Y-%m-%d"),
+                        "date_to": date_next_week.strftime("%Y-%m-%d"),
+                    },
                     "series": [
                         {
                             "kind": "EventsNode",
@@ -738,7 +793,8 @@ def test_csv_exporter_trends_query_with_compare_previous_option(
                         },
                     ],
                     "interval": "day",
-                    "compareFilter": {"compare": True},
+                    "compareFilter": {"compare": True, "compare_to": "-1w"},
+                    "breakdownFilter": {"breakdown": "$browser", "breakdown_type": "event"},
                 }
             },
         )
@@ -747,5 +803,17 @@ def test_csv_exporter_trends_query_with_compare_previous_option(
         with self.settings(OBJECT_STORAGE_ENABLED=True, OBJECT_STORAGE_EXPORTS_FOLDER="Test-Exports"):
             csv_exporter.export_tabular(exported_asset)
             content = object_storage.read(exported_asset.content_location)  # type: ignore
-            lines = (content or "").strip().split("\r\n")
-            self.assertEqual(lines, ["series,22-Mar-2023", "$pageview - current,1", "$pageview - previous,2"])
+
+            lines = (content or "").strip().splitlines()
+
+            expected_lines = [
+                "series,21-Mar-2023,22-Mar-2023,23-Mar-2023,24-Mar-2023,25-Mar-2023,26-Mar-2023,27-Mar-2023,28-Mar-2023",
+                "Chrome - current,2.0,0.0,0.0,0.0,0.0,0.0,0.0,3.0",
+                "Firefox - current,1.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0",
+                "Safari - current,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0",
+                "Chrome - previous,0.0,0.0,0.0,0.0,0.0,0.0,0.0,2.0",
+                "Firefox - previous,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0",
+                "Safari - previous,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0",
+            ]
+
+            self.assertEqual(lines, expected_lines)
diff --git a/posthog/tasks/periodic_digest.py b/posthog/tasks/periodic_digest.py
new file mode 100644
index 0000000000000..c0b6995b1e91f
--- /dev/null
+++ b/posthog/tasks/periodic_digest.py
@@ -0,0 +1,271 @@
+import dataclasses
+from datetime import datetime, timedelta
+from typing import Any, Optional
+from zoneinfo import ZoneInfo
+
+import structlog
+from celery import shared_task
+from dateutil import parser
+from django.db.models import QuerySet
+from django.utils import timezone
+from sentry_sdk import capture_exception
+
+from posthog.models.dashboard import Dashboard
+from posthog.models.event_definition import EventDefinition
+from posthog.models.experiment import Experiment
+from posthog.models.feature_flag import FeatureFlag
+from posthog.models.feedback.survey import Survey
+from posthog.models.messaging import MessagingRecord
+from posthog.models.team.team import Team
+from posthog.session_recordings.models.session_recording_playlist import (
+    SessionRecordingPlaylist,
+)
+from posthog.tasks.usage_report import (
+    USAGE_REPORT_TASK_KWARGS,
+    capture_report,
+    get_instance_metadata,
+)
+from posthog.tasks.utils import CeleryQueue
+from posthog.warehouse.models.external_data_source import ExternalDataSource
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclasses.dataclass
+class periodicDigestReport:
+    new_dashboards: list[dict[str, str]]
+    new_event_definitions: list[dict[str, str]]
+    new_playlists: list[dict[str, str]]
+    new_experiments_launched: list[dict[str, str]]
+    new_experiments_completed: list[dict[str, str]]
+    new_external_data_sources: list[dict[str, str]]
+    new_surveys_launched: list[dict[str, str]]
+    new_feature_flags: list[dict[str, str]]
+
+
+def get_teams_for_digest() -> list[Team]:
+    from django.db.models import Q
+
+    return list(
+        Team.objects.select_related("organization")
+        .exclude(Q(organization__for_internal_metrics=True) | Q(is_demo=True))
+        .only("id", "name", "organization__id", "organization__name", "organization__created_at")
+    )
+
+
+def get_teams_with_new_dashboards(end: datetime, begin: datetime) -> QuerySet:
+    return Dashboard.objects.filter(created_at__gt=begin, created_at__lte=end).values("team_id", "name", "id")
+
+
+def get_teams_with_new_event_definitions(end: datetime, begin: datetime) -> QuerySet:
+    return EventDefinition.objects.filter(created_at__gt=begin, created_at__lte=end).values("team_id", "name", "id")
+
+
+def get_teams_with_new_playlists(end: datetime, begin: datetime) -> QuerySet:
+    return SessionRecordingPlaylist.objects.filter(created_at__gt=begin, created_at__lte=end).values(
+        "team_id", "name", "short_id"
+    )
+
+
+def get_teams_with_new_experiments_launched(end: datetime, begin: datetime) -> QuerySet:
+    return Experiment.objects.filter(start_date__gt=begin, start_date__lte=end).values(
+        "team_id", "name", "id", "start_date"
+    )
+
+
+def get_teams_with_new_experiments_completed(end: datetime, begin: datetime) -> QuerySet:
+    return Experiment.objects.filter(end_date__gt=begin, end_date__lte=end).values(
+        "team_id", "name", "id", "start_date", "end_date"
+    )
+
+
+def get_teams_with_new_external_data_sources(end: datetime, begin: datetime) -> QuerySet:
+    return ExternalDataSource.objects.filter(created_at__gt=begin, created_at__lte=end, deleted=False).values(
+        "team_id", "source_type", "id"
+    )
+
+
+def get_teams_with_new_surveys_launched(end: datetime, begin: datetime) -> QuerySet:
+    return Survey.objects.filter(start_date__gt=begin, start_date__lte=end).values(
+        "team_id", "name", "id", "description", "start_date"
+    )
+
+
+def get_teams_with_new_feature_flags(end: datetime, begin: datetime) -> QuerySet:
+    return (
+        FeatureFlag.objects.filter(
+            created_at__gt=begin,
+            created_at__lte=end,
+            deleted=False,
+        )
+        .exclude(name__contains="Feature Flag for Experiment")
+        .exclude(name__contains="Targeting flag for survey")
+        .values("team_id", "name", "id", "key")
+    )
+
+
+def convert_team_digest_items_to_dict(items: QuerySet) -> dict[int, QuerySet]:
+    return {team_id: items.filter(team_id=team_id) for team_id in items.values_list("team_id", flat=True).distinct()}
+
+
+def count_non_zero_digest_items(report: periodicDigestReport) -> int:
+    return sum(1 for key in report.__dataclass_fields__ if len(getattr(report, key)) > 0)
+
+
+def _get_all_digest_data_as_team_rows(period_start: datetime, period_end: datetime) -> dict[str, Any]:
+    all_digest_data = _get_all_digest_data(period_start, period_end)
+    # convert it to a map of team_id -> value
+    for key, rows in all_digest_data.items():
+        all_digest_data[key] = convert_team_digest_items_to_dict(rows)
+    return all_digest_data
+
+
+def _get_all_digest_data(period_start: datetime, period_end: datetime) -> dict[str, Any]:
+    return {
+        "teams_with_new_dashboards": get_teams_with_new_dashboards(period_end, period_start),
+        "teams_with_new_event_definitions": get_teams_with_new_event_definitions(period_end, period_start),
+        "teams_with_new_playlists": get_teams_with_new_playlists(period_end, period_start),
+        "teams_with_new_experiments_launched": get_teams_with_new_experiments_launched(period_end, period_start),
+        "teams_with_new_experiments_completed": get_teams_with_new_experiments_completed(period_end, period_start),
+        "teams_with_new_external_data_sources": get_teams_with_new_external_data_sources(period_end, period_start),
+        "teams_with_new_surveys_launched": get_teams_with_new_surveys_launched(period_end, period_start),
+        "teams_with_new_feature_flags": get_teams_with_new_feature_flags(period_end, period_start),
+    }
+
+
+def get_periodic_digest_report(all_digest_data: dict[str, Any], team: Team) -> periodicDigestReport:
+    return periodicDigestReport(
+        new_dashboards=[
+            {"name": dashboard.get("name"), "id": dashboard.get("id")}
+            for dashboard in all_digest_data["teams_with_new_dashboards"].get(team.id, [])
+        ],
+        new_event_definitions=[
+            {"name": event_definition.get("name"), "id": event_definition.get("id")}
+            for event_definition in all_digest_data["teams_with_new_event_definitions"].get(team.id, [])
+        ],
+        new_playlists=[
+            {"name": playlist.get("name"), "id": playlist.get("short_id")}
+            for playlist in all_digest_data["teams_with_new_playlists"].get(team.id, [])
+        ],
+        new_experiments_launched=[
+            {
+                "name": experiment.get("name"),
+                "id": experiment.get("id"),
+                "start_date": experiment.get("start_date").isoformat(),
+            }
+            for experiment in all_digest_data["teams_with_new_experiments_launched"].get(team.id, [])
+        ],
+        new_experiments_completed=[
+            {
+                "name": experiment.get("name"),
+                "id": experiment.get("id"),
+                "start_date": experiment.get("start_date").isoformat(),
+                "end_date": experiment.get("end_date").isoformat(),
+            }
+            for experiment in all_digest_data["teams_with_new_experiments_completed"].get(team.id, [])
+        ],
+        new_external_data_sources=[
+            {"source_type": source.get("source_type"), "id": source.get("id")}
+            for source in all_digest_data["teams_with_new_external_data_sources"].get(team.id, [])
+        ],
+        new_surveys_launched=[
+            {
+                "name": survey.get("name"),
+                "id": survey.get("id"),
+                "start_date": survey.get("start_date").isoformat(),
+                "description": survey.get("description"),
+            }
+            for survey in all_digest_data["teams_with_new_surveys_launched"].get(team.id, [])
+        ],
+        new_feature_flags=[
+            {"name": feature_flag.get("name"), "id": feature_flag.get("id"), "key": feature_flag.get("key")}
+            for feature_flag in all_digest_data["teams_with_new_feature_flags"].get(team.id, [])
+        ],
+    )
+
+
+@shared_task(queue=CeleryQueue.USAGE_REPORTS.value, ignore_result=True, max_retries=3)
+def send_periodic_digest_report(
+    *,
+    team_id: int,
+    team_name: str,
+    periodic_digest_report: dict[str, Any],
+    instance_metadata: dict[str, Any],
+    period_end: datetime,
+    period_start: datetime,
+    digest_items_with_data: int,
+) -> None:
+    period_str = period_end.strftime("%Y-%m-%d")
+    days = (period_end - period_start).days
+    campaign_key = f"periodic_digest_{period_str}_{days}d"
+
+    # Use a consistent identifier for the team
+    team_identifier = f"team_{team_id}"
+
+    # Check if we've already sent this digest using get_or_create
+    record, created = MessagingRecord.objects.get_or_create(raw_email=team_identifier, campaign_key=campaign_key)
+
+    if not created and record.sent_at:
+        logger.info(f"Skipping duplicate periodic digest for team {team_id} for period ending {period_str}")
+        return
+
+    full_report_dict = {
+        "team_id": team_id,
+        "team_name": team_name,
+        "template": "periodic_digest_report",
+        "digest_items_with_data": digest_items_with_data,
+        **periodic_digest_report,
+        **instance_metadata,
+    }
+
+    capture_report.delay(
+        capture_event_name="transactional email",
+        team_id=team_id,
+        full_report_dict=full_report_dict,
+        send_for_all_members=True,
+    )
+
+    # Mark as sent
+    record.sent_at = timezone.now()
+    record.save()
+
+
+@shared_task(**USAGE_REPORT_TASK_KWARGS, max_retries=0)
+def send_all_periodic_digest_reports(
+    dry_run: bool = False,
+    end_date: Optional[str] = None,
+    begin_date: Optional[str] = None,
+) -> None:
+    period_end = (
+        parser.parse(end_date)
+        if end_date
+        else datetime.now(tz=ZoneInfo("UTC")).replace(hour=0, minute=0, second=0, microsecond=0)
+    )
+    period_start = parser.parse(begin_date) if begin_date else period_end - timedelta(days=7)
+
+    try:
+        all_digest_data = _get_all_digest_data_as_team_rows(period_start, period_end)
+        teams = get_teams_for_digest()
+        time_now = datetime.now()
+        for team in teams:
+            report = get_periodic_digest_report(all_digest_data, team)
+            full_report_dict = dataclasses.asdict(report)
+            instance_metadata = dataclasses.asdict(get_instance_metadata((period_start, period_end)))
+            digest_items_with_data = count_non_zero_digest_items(report)
+
+            # Then capture as events to PostHog, so they can be sent via email
+            if digest_items_with_data > 0 and not dry_run:
+                send_periodic_digest_report.delay(
+                    team_id=team.id,
+                    team_name=team.name,
+                    periodic_digest_report=full_report_dict,
+                    instance_metadata=instance_metadata,
+                    period_end=period_end,
+                    period_start=period_start,
+                    digest_items_with_data=digest_items_with_data,
+                )
+        time_since = datetime.now() - time_now
+        logger.debug(f"Sending usage reports to PostHog and Billing took {time_since.total_seconds()} seconds.")  # noqa T201
+    except Exception as err:
+        capture_exception(err)
+        raise
diff --git a/posthog/tasks/poll_query_performance.py b/posthog/tasks/poll_query_performance.py
index f035c82629064..51e7ebeefd5a6 100644
--- a/posthog/tasks/poll_query_performance.py
+++ b/posthog/tasks/poll_query_performance.py
@@ -7,6 +7,7 @@
 from posthog.clickhouse.client.connection import Workload
 from posthog.clickhouse.client.execute_async import QueryStatusManager
 from posthog.utils import UUID_REGEX
+from posthog.settings import CLICKHOUSE_CLUSTER
 import re
 import math
 
@@ -33,7 +34,7 @@ def get_query_results() -> list[Any]:
             elapsed,
             ProfileEvents['OSCPUVirtualTimeMicroseconds'] as OSCPUVirtualTimeMicroseconds,
             query_id
-        FROM clusterAllReplicas(posthog, system.processes)
+        FROM clusterAllReplicas(%(cluster)s, system.processes)
         WHERE initial_query_id REGEXP '\d+_[0-9a-f]{8}-'
         UNION ALL SELECT
             initial_query_id,
@@ -43,12 +44,13 @@ def get_query_results() -> list[Any]:
             query_duration_ms / 1000 as elapsed,
             ProfileEvents['OSCPUVirtualTimeMicroseconds'] as OSCPUVirtualTimeMicroseconds,
             query_id
-        FROM clusterAllReplicas(posthog, system.query_log)
+        FROM clusterAllReplicas(%(cluster)s, system.query_log)
         WHERE initial_query_id REGEXP '\d+_[0-9a-f]{8}-'
         AND type = 'QueryFinish'
         AND event_time > subtractSeconds(now(), 10)
         """
-    raw_results = sync_execute(SYSTEM_PROCESSES_SQL, workload=Workload.ONLINE)
+
+    raw_results = sync_execute(SYSTEM_PROCESSES_SQL, {"cluster": CLICKHOUSE_CLUSTER}, workload=Workload.ONLINE)
 
     noNaNInt = lambda num: 0 if math.isnan(num) else int(num)
 
diff --git a/posthog/tasks/remote_config.py b/posthog/tasks/remote_config.py
new file mode 100644
index 0000000000000..2b50c52da0c4f
--- /dev/null
+++ b/posthog/tasks/remote_config.py
@@ -0,0 +1,33 @@
+from celery import shared_task
+import structlog
+
+from posthog.models.remote_config import RemoteConfig
+from posthog.tasks.utils import CeleryQueue
+from posthog.models.team import Team
+
+logger = structlog.get_logger(__name__)
+
+
+@shared_task(ignore_result=True, queue=CeleryQueue.DEFAULT.value)
+def update_team_remote_config(team_id: int) -> None:
+    try:
+        team = Team.objects.get(id=team_id)
+    except Team.DoesNotExist:
+        logger.exception("Team does not exist", team_id=team_id)
+        return
+
+    try:
+        remote_config = RemoteConfig.objects.get(team=team)
+    except RemoteConfig.DoesNotExist:
+        remote_config = RemoteConfig(team=team)
+
+    remote_config.sync()
+
+
+@shared_task(ignore_result=True, queue=CeleryQueue.DEFAULT.value)
+def sync_all_remote_configs() -> None:
+    # Meant to ensure we have all configs in sync in case something failed
+
+    # Only select the id from the team queryset
+    for team_id in Team.objects.values_list("id", flat=True):
+        update_team_remote_config.delay(team_id)
diff --git a/posthog/tasks/scheduled.py b/posthog/tasks/scheduled.py
index 5972857f7fd2b..8912d1e362be3 100644
--- a/posthog/tasks/scheduled.py
+++ b/posthog/tasks/scheduled.py
@@ -9,12 +9,13 @@
 from posthog.caching.warming import schedule_warming_for_teams_task
 from posthog.celery import app
 from posthog.tasks.alerts.checks import (
+    alerts_backlog_task,
     check_alerts_task,
     checks_cleanup_task,
-    alerts_backlog_task,
     reset_stuck_alerts_task,
 )
 from posthog.tasks.integrations import refresh_integrations
+from posthog.tasks.periodic_digest import send_all_periodic_digest_reports
 from posthog.tasks.tasks import (
     calculate_cohort,
     calculate_decide_usage,
@@ -51,12 +52,14 @@
     sync_all_organization_available_product_features,
     update_event_partitions,
     update_quota_limiting,
+    update_survey_adaptive_sampling,
     update_survey_iteration,
     verify_persons_data_in_sync,
-    update_survey_adaptive_sampling,
 )
 from posthog.utils import get_crontab
 
+from posthog.tasks.remote_config import sync_all_remote_configs
+
 
 def add_periodic_task_with_expiry(
     sender: Celery,
@@ -129,6 +132,13 @@ def setup_periodic_tasks(sender: Celery, **kwargs: Any) -> None:
         name="update quota limiting",
     )
 
+    # Send all periodic digest reports
+    sender.add_periodic_task(
+        crontab(hour="9", minute="0", day_of_week="mon"),
+        send_all_periodic_digest_reports.s(),
+        name="send all weekly digest reports",
+    )
+
     # PostHog Cloud cron jobs
     # NOTE: We can't use is_cloud here as some Django elements aren't loaded yet. We check in the task execution instead
     # Verify that persons data is in sync every day at 4 AM UTC
@@ -350,3 +360,9 @@ def setup_periodic_tasks(sender: Celery, **kwargs: Any) -> None:
         refresh_integrations.s(),
         name="refresh integrations",
     )
+
+    sender.add_periodic_task(
+        crontab(hour="0", minute=str(randrange(0, 40))),
+        sync_all_remote_configs.s(),
+        name="sync all remote configs",
+    )
diff --git a/posthog/tasks/test/__snapshots__/test_process_scheduled_changes.ambr b/posthog/tasks/test/__snapshots__/test_process_scheduled_changes.ambr
index 64eda354dd032..563d97146fefe 100644
--- a/posthog/tasks/test/__snapshots__/test_process_scheduled_changes.ambr
+++ b/posthog/tasks/test/__snapshots__/test_process_scheduled_changes.ambr
@@ -24,27 +24,1102 @@
 # ---
 # name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.1
   '''
-  SELECT "posthog_scheduledchange"."id",
-         "posthog_scheduledchange"."record_id",
-         "posthog_scheduledchange"."model_name",
-         "posthog_scheduledchange"."payload",
-         "posthog_scheduledchange"."scheduled_at",
-         "posthog_scheduledchange"."executed_at",
-         "posthog_scheduledchange"."failure_reason",
-         "posthog_scheduledchange"."team_id",
-         "posthog_scheduledchange"."created_at",
-         "posthog_scheduledchange"."created_by_id",
-         "posthog_scheduledchange"."updated_at"
-  FROM "posthog_scheduledchange"
-  WHERE ("posthog_scheduledchange"."executed_at" IS NULL
-         AND "posthog_scheduledchange"."scheduled_at" <= '2023-12-21 09:00:00+00:00'::timestamptz)
-  ORDER BY "posthog_scheduledchange"."scheduled_at" ASC
-  LIMIT 10000
-  FOR
-  UPDATE NOWAIT
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.10
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."requested_password_reset_at",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.11
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.12
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.13
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.14
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.15
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.16
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.17
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.18
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.19
+  '''
+  SELECT "posthog_organization"."id",
+         "posthog_organization"."name",
+         "posthog_organization"."slug",
+         "posthog_organization"."logo_media_id",
+         "posthog_organization"."created_at",
+         "posthog_organization"."updated_at",
+         "posthog_organization"."plugins_access_level",
+         "posthog_organization"."for_internal_metrics",
+         "posthog_organization"."is_member_join_email_enabled",
+         "posthog_organization"."enforce_2fa",
+         "posthog_organization"."is_hipaa",
+         "posthog_organization"."customer_id",
+         "posthog_organization"."available_product_features",
+         "posthog_organization"."usage",
+         "posthog_organization"."never_drop_data",
+         "posthog_organization"."customer_trust_scores",
+         "posthog_organization"."setup_section_2_completed",
+         "posthog_organization"."personalization",
+         "posthog_organization"."domain_whitelist"
+  FROM "posthog_organization"
+  WHERE "posthog_organization"."id" = '00000000-0000-0000-0000-000000000000'::uuid
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.2
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.20
+  '''
+  SELECT "posthog_experiment"."id",
+         "posthog_experiment"."name",
+         "posthog_experiment"."description",
+         "posthog_experiment"."team_id",
+         "posthog_experiment"."filters",
+         "posthog_experiment"."parameters",
+         "posthog_experiment"."secondary_metrics",
+         "posthog_experiment"."created_by_id",
+         "posthog_experiment"."feature_flag_id",
+         "posthog_experiment"."exposure_cohort_id",
+         "posthog_experiment"."holdout_id",
+         "posthog_experiment"."start_date",
+         "posthog_experiment"."end_date",
+         "posthog_experiment"."created_at",
+         "posthog_experiment"."updated_at",
+         "posthog_experiment"."archived",
+         "posthog_experiment"."type",
+         "posthog_experiment"."variants",
+         "posthog_experiment"."metrics",
+         "posthog_experiment"."metrics_secondary"
+  FROM "posthog_experiment"
+  WHERE "posthog_experiment"."feature_flag_id" = 99999
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.21
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.22
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE "posthog_featureflag"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.23
+  '''
+  SELECT "posthog_user"."id",
+         "posthog_user"."password",
+         "posthog_user"."last_login",
+         "posthog_user"."first_name",
+         "posthog_user"."last_name",
+         "posthog_user"."is_staff",
+         "posthog_user"."date_joined",
+         "posthog_user"."uuid",
+         "posthog_user"."current_organization_id",
+         "posthog_user"."current_team_id",
+         "posthog_user"."email",
+         "posthog_user"."pending_email",
+         "posthog_user"."temporary_token",
+         "posthog_user"."distinct_id",
+         "posthog_user"."is_email_verified",
+         "posthog_user"."requested_password_reset_at",
+         "posthog_user"."has_seen_product_intro_for",
+         "posthog_user"."strapi_id",
+         "posthog_user"."is_active",
+         "posthog_user"."theme_mode",
+         "posthog_user"."partial_notification_settings",
+         "posthog_user"."anonymize_data",
+         "posthog_user"."toolbar_mode",
+         "posthog_user"."hedgehog_config",
+         "posthog_user"."events_column_config",
+         "posthog_user"."email_opt_in"
+  FROM "posthog_user"
+  WHERE "posthog_user"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.24
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.25
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.26
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.27
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.28
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.29
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.3
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.30
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.31
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.10
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.32
   '''
   SELECT "posthog_organization"."id",
          "posthog_organization"."name",
@@ -70,7 +1145,33 @@
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.11
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.33
+  '''
+  SELECT "posthog_experiment"."id",
+         "posthog_experiment"."name",
+         "posthog_experiment"."description",
+         "posthog_experiment"."team_id",
+         "posthog_experiment"."filters",
+         "posthog_experiment"."parameters",
+         "posthog_experiment"."secondary_metrics",
+         "posthog_experiment"."created_by_id",
+         "posthog_experiment"."feature_flag_id",
+         "posthog_experiment"."exposure_cohort_id",
+         "posthog_experiment"."holdout_id",
+         "posthog_experiment"."start_date",
+         "posthog_experiment"."end_date",
+         "posthog_experiment"."created_at",
+         "posthog_experiment"."updated_at",
+         "posthog_experiment"."archived",
+         "posthog_experiment"."type",
+         "posthog_experiment"."variants",
+         "posthog_experiment"."metrics",
+         "posthog_experiment"."metrics_secondary"
+  FROM "posthog_experiment"
+  WHERE "posthog_experiment"."feature_flag_id" = 99999
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.34
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -140,7 +1241,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.12
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.35
   '''
   SELECT "posthog_scheduledchange"."id",
          "posthog_scheduledchange"."record_id",
@@ -158,7 +1259,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.13
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.36
   '''
   SELECT "posthog_scheduledchange"."id",
          "posthog_scheduledchange"."record_id",
@@ -176,7 +1277,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.14
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.37
   '''
   SELECT "posthog_scheduledchange"."id",
          "posthog_scheduledchange"."record_id",
@@ -194,7 +1295,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.15
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.38
   '''
   SELECT "posthog_scheduledchange"."id",
          "posthog_scheduledchange"."record_id",
@@ -212,7 +1313,7 @@
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.16
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.39
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -234,7 +1335,52 @@
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.2
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.4
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.40
+  '''
+  SELECT "posthog_scheduledchange"."id",
+         "posthog_scheduledchange"."record_id",
+         "posthog_scheduledchange"."model_name",
+         "posthog_scheduledchange"."payload",
+         "posthog_scheduledchange"."scheduled_at",
+         "posthog_scheduledchange"."executed_at",
+         "posthog_scheduledchange"."failure_reason",
+         "posthog_scheduledchange"."team_id",
+         "posthog_scheduledchange"."created_at",
+         "posthog_scheduledchange"."created_by_id",
+         "posthog_scheduledchange"."updated_at"
+  FROM "posthog_scheduledchange"
+  WHERE "posthog_scheduledchange"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.41
+  '''
+  SELECT "posthog_scheduledchange"."id",
+         "posthog_scheduledchange"."record_id",
+         "posthog_scheduledchange"."model_name",
+         "posthog_scheduledchange"."payload",
+         "posthog_scheduledchange"."scheduled_at",
+         "posthog_scheduledchange"."executed_at",
+         "posthog_scheduledchange"."failure_reason",
+         "posthog_scheduledchange"."team_id",
+         "posthog_scheduledchange"."created_at",
+         "posthog_scheduledchange"."created_by_id",
+         "posthog_scheduledchange"."updated_at"
+  FROM "posthog_scheduledchange"
+  WHERE "posthog_scheduledchange"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.42
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -252,46 +1398,42 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
-  WHERE "posthog_featureflag"."id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.3
-  '''
-  SELECT "posthog_user"."id",
-         "posthog_user"."password",
-         "posthog_user"."last_login",
-         "posthog_user"."first_name",
-         "posthog_user"."last_name",
-         "posthog_user"."is_staff",
-         "posthog_user"."date_joined",
-         "posthog_user"."uuid",
-         "posthog_user"."current_organization_id",
-         "posthog_user"."current_team_id",
-         "posthog_user"."email",
-         "posthog_user"."pending_email",
-         "posthog_user"."temporary_token",
-         "posthog_user"."distinct_id",
-         "posthog_user"."is_email_verified",
-         "posthog_user"."requested_password_reset_at",
-         "posthog_user"."has_seen_product_intro_for",
-         "posthog_user"."strapi_id",
-         "posthog_user"."is_active",
-         "posthog_user"."theme_mode",
-         "posthog_user"."partial_notification_settings",
-         "posthog_user"."anonymize_data",
-         "posthog_user"."toolbar_mode",
-         "posthog_user"."hedgehog_config",
-         "posthog_user"."events_column_config",
-         "posthog_user"."email_opt_in"
-  FROM "posthog_user"
-  WHERE "posthog_user"."id" = 99999
+  WHERE "posthog_featureflag"."key" = 'flag-1'
   LIMIT 21
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.4
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.5
   '''
-  SELECT "posthog_featureflag"."id",
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
          "posthog_featureflag"."key",
          "posthog_featureflag"."name",
          "posthog_featureflag"."filters",
@@ -305,42 +1447,85 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.5
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.6
   '''
-  SELECT "posthog_organization"."id",
-         "posthog_organization"."name",
-         "posthog_organization"."slug",
-         "posthog_organization"."logo_media_id",
-         "posthog_organization"."created_at",
-         "posthog_organization"."updated_at",
-         "posthog_organization"."plugins_access_level",
-         "posthog_organization"."for_internal_metrics",
-         "posthog_organization"."is_member_join_email_enabled",
-         "posthog_organization"."enforce_2fa",
-         "posthog_organization"."is_hipaa",
-         "posthog_organization"."customer_id",
-         "posthog_organization"."available_product_features",
-         "posthog_organization"."usage",
-         "posthog_organization"."never_drop_data",
-         "posthog_organization"."customer_trust_scores",
-         "posthog_organization"."setup_section_2_completed",
-         "posthog_organization"."personalization",
-         "posthog_organization"."domain_whitelist"
-  FROM "posthog_organization"
-  WHERE "posthog_organization"."id" = '00000000-0000-0000-0000-000000000000'::uuid
-  LIMIT 21
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
   '''
 # ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.6
+# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.7
   '''
-  SELECT "posthog_team"."id",
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
          "posthog_team"."uuid",
          "posthog_team"."organization_id",
          "posthog_team"."project_id",
@@ -403,64 +1588,34 @@
          "posthog_team"."event_properties_numerical",
          "posthog_team"."external_data_workspace_id",
          "posthog_team"."external_data_workspace_last_synced_at"
-  FROM "posthog_team"
-  WHERE "posthog_team"."id" = 99999
-  LIMIT 21
-  '''
-# ---
-# name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.7
-  '''
-  SELECT "posthog_featureflag"."id",
-         "posthog_featureflag"."key",
-         "posthog_featureflag"."name",
-         "posthog_featureflag"."filters",
-         "posthog_featureflag"."rollout_percentage",
-         "posthog_featureflag"."team_id",
-         "posthog_featureflag"."created_by_id",
-         "posthog_featureflag"."created_at",
-         "posthog_featureflag"."deleted",
-         "posthog_featureflag"."active",
-         "posthog_featureflag"."rollback_conditions",
-         "posthog_featureflag"."performed_rollback",
-         "posthog_featureflag"."ensure_experience_continuity",
-         "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE "posthog_featureflag"."id" = 99999
-  LIMIT 21
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
 # name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.8
   '''
-  SELECT "posthog_user"."id",
-         "posthog_user"."password",
-         "posthog_user"."last_login",
-         "posthog_user"."first_name",
-         "posthog_user"."last_name",
-         "posthog_user"."is_staff",
-         "posthog_user"."date_joined",
-         "posthog_user"."uuid",
-         "posthog_user"."current_organization_id",
-         "posthog_user"."current_team_id",
-         "posthog_user"."email",
-         "posthog_user"."pending_email",
-         "posthog_user"."temporary_token",
-         "posthog_user"."distinct_id",
-         "posthog_user"."is_email_verified",
-         "posthog_user"."requested_password_reset_at",
-         "posthog_user"."has_seen_product_intro_for",
-         "posthog_user"."strapi_id",
-         "posthog_user"."is_active",
-         "posthog_user"."theme_mode",
-         "posthog_user"."partial_notification_settings",
-         "posthog_user"."anonymize_data",
-         "posthog_user"."toolbar_mode",
-         "posthog_user"."hedgehog_config",
-         "posthog_user"."events_column_config",
-         "posthog_user"."email_opt_in"
-  FROM "posthog_user"
-  WHERE "posthog_user"."id" = 99999
-  LIMIT 21
+  SELECT "posthog_scheduledchange"."id",
+         "posthog_scheduledchange"."record_id",
+         "posthog_scheduledchange"."model_name",
+         "posthog_scheduledchange"."payload",
+         "posthog_scheduledchange"."scheduled_at",
+         "posthog_scheduledchange"."executed_at",
+         "posthog_scheduledchange"."failure_reason",
+         "posthog_scheduledchange"."team_id",
+         "posthog_scheduledchange"."created_at",
+         "posthog_scheduledchange"."created_by_id",
+         "posthog_scheduledchange"."updated_at"
+  FROM "posthog_scheduledchange"
+  WHERE ("posthog_scheduledchange"."executed_at" IS NULL
+         AND "posthog_scheduledchange"."scheduled_at" <= '2023-12-21 09:00:00+00:00'::timestamptz)
+  ORDER BY "posthog_scheduledchange"."scheduled_at" ASC
+  LIMIT 10000
+  FOR
+  UPDATE NOWAIT
   '''
 # ---
 # name: TestProcessScheduledChanges.test_schedule_feature_flag_multiple_changes.9
@@ -481,8 +1636,7 @@
          "posthog_featureflag"."usage_dashboard_id",
          "posthog_featureflag"."has_enriched_analytics"
   FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+  WHERE "posthog_featureflag"."id" = 99999
+  LIMIT 21
   '''
 # ---
diff --git a/posthog/tasks/test/__snapshots__/test_usage_report.ambr b/posthog/tasks/test/__snapshots__/test_usage_report.ambr
index 2230c532da5ca..36733da586c57 100644
--- a/posthog/tasks/test/__snapshots__/test_usage_report.ambr
+++ b/posthog/tasks/test/__snapshots__/test_usage_report.ambr
@@ -3,7 +3,7 @@
   '''
   
   SELECT team_id,
-         multiIf(event LIKE 'helicone%', 'helicone_events', event LIKE 'langfuse%', 'langfuse_events', event LIKE 'keywords_ai%', 'keywords_ai_events', event LIKE 'traceloop%', 'traceloop_events', JSONExtractString(properties, '$lib') = 'web', 'web_events', JSONExtractString(properties, '$lib') = 'js', 'web_lite_events', JSONExtractString(properties, '$lib') = 'posthog-node', 'node_events', JSONExtractString(properties, '$lib') = 'posthog-android', 'android_events', JSONExtractString(properties, '$lib') = 'posthog-flutter', 'flutter_events', JSONExtractString(properties, '$lib') = 'posthog-ios', 'ios_events', JSONExtractString(properties, '$lib') = 'posthog-go', 'go_events', JSONExtractString(properties, '$lib') = 'posthog-java', 'java_events', JSONExtractString(properties, '$lib') = 'posthog-react-native', 'react_native_events', JSONExtractString(properties, '$lib') = 'posthog-ruby', 'ruby_events', JSONExtractString(properties, '$lib') = 'posthog-python', 'python_events', JSONExtractString(properties, '$lib') = 'posthog-php', 'php_events', 'other') AS metric,
+         multiIf(event LIKE 'helicone%', 'helicone_events', event LIKE 'langfuse%', 'langfuse_events', event LIKE 'keywords_ai%', 'keywords_ai_events', event LIKE 'traceloop%', 'traceloop_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'web', 'web_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'js', 'web_lite_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-node', 'node_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-android', 'android_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-flutter', 'flutter_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-ios', 'ios_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-go', 'go_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-java', 'java_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-react-native', 'react_native_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-ruby', 'ruby_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-python', 'python_events', replaceRegexpAll(JSONExtractRaw(properties, '$lib'), '^"|"$', '') = 'posthog-php', 'php_events', 'other') AS metric,
          count(1) as count
   FROM events
   WHERE timestamp BETWEEN '2022-01-10 00:00:00' AND '2022-01-10 23:59:59'
diff --git a/posthog/tasks/test/test_periodic_digest.py b/posthog/tasks/test/test_periodic_digest.py
new file mode 100644
index 0000000000000..4d495eac6aa8d
--- /dev/null
+++ b/posthog/tasks/test/test_periodic_digest.py
@@ -0,0 +1,353 @@
+from datetime import datetime, timedelta
+from unittest.mock import ANY, MagicMock, patch
+from uuid import uuid4
+
+from django.utils.timezone import now
+from freezegun import freeze_time
+
+from posthog.models import Dashboard, EventDefinition, Experiment, FeatureFlag, Survey
+from posthog.models.messaging import MessagingRecord
+from posthog.session_recordings.models.session_recording_playlist import (
+    SessionRecordingPlaylist,
+)
+from posthog.tasks.periodic_digest import send_all_periodic_digest_reports
+from posthog.test.base import APIBaseTest
+from posthog.warehouse.models import ExternalDataSource
+
+
+@freeze_time("2024-01-01T00:01:00Z")  # A Monday
+class TestPeriodicDigestReport(APIBaseTest):
+    def setUp(self) -> None:
+        super().setUp()
+        self.distinct_id = str(uuid4())
+
+    @freeze_time("2024-01-20T00:01:00Z")
+    @patch("posthog.tasks.periodic_digest.capture_report")
+    def test_periodic_digest_report(self, mock_capture: MagicMock) -> None:
+        # Create test data from "last week"
+        with freeze_time("2024-01-15T00:01:00Z"):
+            # Create a dashboard
+            dashboard = Dashboard.objects.create(
+                team=self.team,
+                name="Test Dashboard",
+            )
+
+            # Create an event definition
+            event_definition = EventDefinition.objects.create(
+                team=self.team,
+                name="Test Event",
+            )
+
+            # Create a playlist
+            playlist = SessionRecordingPlaylist.objects.create(
+                team=self.team,
+                name="Test Playlist",
+            )
+
+            # Create experiments
+            # this flag should not be included in the digest
+            flag_for_launched_experiment = FeatureFlag.objects.create(
+                team=self.team,
+                name="Feature Flag for Experiment My experiment 1",
+                key="flag-for-launched-experiment",
+            )
+            launched_experiment = Experiment.objects.create(
+                team=self.team,
+                name="Launched Experiment",
+                start_date=now(),
+                feature_flag=flag_for_launched_experiment,
+            )
+
+            # Create external data source
+            external_data_source = ExternalDataSource.objects.create(
+                team=self.team,
+                source_id="test_source",
+                connection_id="test_connection",
+                status="completed",
+                source_type="Stripe",
+            )
+
+            # Create a survey
+            # this flag should not be included in the digest since it's generated for the survey
+            flag_for_survey = FeatureFlag.objects.create(
+                team=self.team,
+                name="Targeting flag for survey My survey",
+                key="feature-flag-for-survey",
+            )
+            survey = Survey.objects.create(
+                team=self.team,
+                name="Test Survey",
+                description="Test Description",
+                start_date=now(),
+                targeting_flag=flag_for_survey,
+            )
+
+            # Create a feature flag
+            feature_flag = FeatureFlag.objects.create(
+                team=self.team,
+                name="Test Flag",
+                key="test-flag",
+            )
+
+        with freeze_time("2024-01-10T00:01:00Z"):
+            # this flag should not be included in the digest
+            flag_for_completed_experiment = FeatureFlag.objects.create(
+                team=self.team,
+                name="Feature Flag for Experiment My experiment 2",
+                key="feature-flag-for-completed-experiment",
+            )
+            # completed experiment is not included in the list of launched experiments
+            # but is included in the list of completed experiments
+            completed_experiment = Experiment.objects.create(
+                team=self.team,
+                name="Completed Experiment",
+                start_date=now() + timedelta(days=1),
+                end_date=now() + timedelta(days=6),
+                feature_flag=flag_for_completed_experiment,
+            )
+
+        # Run the periodic digest report task
+        send_all_periodic_digest_reports()
+
+        # Check that the capture event was called with the correct data
+        expected_properties = {
+            "team_id": self.team.id,
+            "team_name": self.team.name,
+            "template": "periodic_digest_report",
+            "users_who_logged_in": [],
+            "users_who_logged_in_count": 0,
+            "users_who_signed_up": [],
+            "users_who_signed_up_count": 0,
+            "period": {
+                "end_inclusive": "2024-01-20T00:00:00+00:00",
+                "start_inclusive": "2024-01-13T00:00:00+00:00",
+            },
+            "plugins_enabled": {},
+            "plugins_installed": {},
+            "product": "open source",
+            "realm": "hosted-clickhouse",
+            "site_url": "http://localhost:8000",
+            "table_sizes": ANY,
+            "clickhouse_version": ANY,
+            "deployment_infrastructure": "unknown",
+            "helm": {},
+            "instance_tag": "none",
+            "new_dashboards": [
+                {
+                    "name": "Test Dashboard",
+                    "id": dashboard.id,
+                }
+            ],
+            "new_event_definitions": [
+                {
+                    "name": "Test Event",
+                    "id": event_definition.id,
+                }
+            ],
+            "new_playlists": [
+                {
+                    "name": "Test Playlist",
+                    "id": playlist.short_id,
+                }
+            ],
+            "new_experiments_launched": [
+                {
+                    "name": "Launched Experiment",
+                    "id": launched_experiment.id,
+                    "start_date": launched_experiment.start_date.isoformat(),  # type: ignore
+                }
+            ],
+            "new_experiments_completed": [
+                {
+                    "name": "Completed Experiment",
+                    "id": completed_experiment.id,
+                    "start_date": completed_experiment.start_date.isoformat(),  # type: ignore
+                    "end_date": completed_experiment.end_date.isoformat(),  # type: ignore
+                }
+            ],
+            "new_external_data_sources": [
+                {
+                    "source_type": "Stripe",
+                    "id": external_data_source.id,
+                }
+            ],
+            "new_surveys_launched": [
+                {
+                    "name": "Test Survey",
+                    "id": survey.id,
+                    "start_date": survey.start_date.isoformat(),  # type: ignore
+                    "description": "Test Description",
+                }
+            ],
+            "new_feature_flags": [
+                {
+                    "name": "Test Flag",
+                    "id": feature_flag.id,
+                    "key": "test-flag",
+                }
+            ],
+            "digest_items_with_data": 8,
+        }
+
+        mock_capture.delay.assert_called_once_with(
+            capture_event_name="transactional email",
+            team_id=self.team.id,
+            full_report_dict=expected_properties,
+            send_for_all_members=True,
+        )
+
+    @patch("posthog.tasks.periodic_digest.capture_report")
+    def test_periodic_digest_report_dry_run(self, mock_capture: MagicMock) -> None:
+        send_all_periodic_digest_reports(dry_run=True)
+        mock_capture.delay.assert_not_called()
+
+    @patch("posthog.tasks.periodic_digest.capture_report")
+    def test_periodic_digest_report_custom_dates(self, mock_capture: MagicMock) -> None:
+        # Create test data
+        with freeze_time("2024-01-15T00:01:00Z"):
+            dashboard = Dashboard.objects.create(
+                team=self.team,
+                name="Test Dashboard",
+            )
+        with freeze_time("2024-01-13T00:01:00Z"):
+            # outside the range, should be excluded
+            Dashboard.objects.create(
+                team=self.team,
+                name="Test Dashboard",
+            )
+
+        with freeze_time("2024-01-16T00:01:00Z"):
+            end_date = datetime.now()
+            begin_date = end_date - timedelta(days=2)
+
+        # Run the periodic digest report task with custom dates
+        send_all_periodic_digest_reports(begin_date=begin_date.isoformat(), end_date=end_date.isoformat())
+
+        # Check that the capture event was called with the correct data
+        expected_properties = {
+            "team_id": self.team.id,
+            "team_name": self.team.name,
+            "template": "periodic_digest_report",
+            "users_who_logged_in": [],
+            "users_who_logged_in_count": 0,
+            "users_who_signed_up": [],
+            "users_who_signed_up_count": 0,
+            "period": {
+                "end_inclusive": "2024-01-16T00:01:00",
+                "start_inclusive": "2024-01-14T00:01:00",
+            },
+            "plugins_enabled": {},
+            "plugins_installed": {},
+            "product": "open source",
+            "realm": "hosted-clickhouse",
+            "site_url": "http://localhost:8000",
+            "table_sizes": ANY,
+            "clickhouse_version": ANY,
+            "deployment_infrastructure": "unknown",
+            "helm": {},
+            "instance_tag": "none",
+            "new_dashboards": [
+                {
+                    "name": "Test Dashboard",
+                    "id": dashboard.id,
+                }
+            ],
+            "new_event_definitions": [],
+            "new_playlists": [],
+            "new_experiments_launched": [],
+            "new_experiments_completed": [],
+            "new_external_data_sources": [],
+            "new_surveys_launched": [],
+            "new_feature_flags": [],
+            "digest_items_with_data": 1,
+        }
+
+        mock_capture.delay.assert_called_once_with(
+            capture_event_name="transactional email",
+            team_id=self.team.id,
+            full_report_dict=expected_properties,
+            send_for_all_members=True,
+        )
+
+    @freeze_time("2024-01-20T00:01:00Z")
+    @patch("posthog.tasks.periodic_digest.capture_report")
+    def test_periodic_digest_report_idempotency(self, mock_capture: MagicMock) -> None:
+        # Create test data
+        with freeze_time("2024-01-15T00:01:00Z"):
+            Dashboard.objects.create(
+                team=self.team,
+                name="Test Dashboard",
+            )
+
+        # First run - should send the digest
+        send_all_periodic_digest_reports()
+
+        # Verify first call
+        mock_capture.delay.assert_called_once()
+        mock_capture.delay.reset_mock()
+
+        # Check that messaging record was created
+        record = MessagingRecord.objects.get(  # type: ignore
+            raw_email=f"team_{self.team.id}", campaign_key="periodic_digest_2024-01-20_7d"
+        )
+        self.assertIsNotNone(record.sent_at)
+
+        # Second run - should not send the digest again
+        send_all_periodic_digest_reports()
+        mock_capture.delay.assert_not_called()
+
+        # Verify only one record exists
+        self.assertEqual(MessagingRecord.objects.count(), 1)
+
+    @freeze_time("2024-01-20T00:01:00Z")
+    @patch("posthog.tasks.periodic_digest.capture_report")
+    def test_periodic_digest_different_periods(self, mock_capture: MagicMock) -> None:
+        # Create test data
+        with freeze_time("2024-01-15T00:01:00Z"):
+            Dashboard.objects.create(
+                team=self.team,
+                name="Test Dashboard",
+            )
+
+        # Send weekly digest
+        send_all_periodic_digest_reports()
+        mock_capture.delay.assert_called_once()
+        mock_capture.delay.reset_mock()
+
+        # Send monthly digest (different period length)
+        send_all_periodic_digest_reports(
+            begin_date=(datetime.now() - timedelta(days=30)).isoformat(), end_date=datetime.now().isoformat()
+        )
+        mock_capture.delay.assert_called_once()
+
+        # Verify two different records exist
+        records = MessagingRecord.objects.filter(raw_email=f"team_{self.team.id}")  # type: ignore
+        self.assertEqual(records.count(), 2)
+        campaign_keys = sorted([r.campaign_key for r in records])
+        self.assertEqual(campaign_keys, ["periodic_digest_2024-01-20_30d", "periodic_digest_2024-01-20_7d"])
+
+    @freeze_time("2024-01-20T00:01:00Z")
+    @patch("posthog.tasks.periodic_digest.capture_report")
+    def test_periodic_digest_empty_report_no_record(self, mock_capture: MagicMock) -> None:
+        # Run without any data (empty digest)
+        send_all_periodic_digest_reports()
+
+        # Verify no capture call and no messaging record
+        mock_capture.delay.assert_not_called()
+        self.assertEqual(MessagingRecord.objects.count(), 0)
+
+    @freeze_time("2024-01-20T00:01:00Z")
+    @patch("posthog.tasks.periodic_digest.capture_report")
+    def test_periodic_digest_dry_run_no_record(self, mock_capture: MagicMock) -> None:
+        # Create test data
+        Dashboard.objects.create(
+            team=self.team,
+            name="Test Dashboard",
+        )
+
+        # Run in dry_run mode
+        send_all_periodic_digest_reports(dry_run=True)
+
+        # Verify no capture call and no messaging record
+        mock_capture.delay.assert_not_called()
+        self.assertEqual(MessagingRecord.objects.count(), 0)
diff --git a/posthog/tasks/test/test_remote_config.py b/posthog/tasks/test/test_remote_config.py
new file mode 100644
index 0000000000000..0f6a8500d4a7b
--- /dev/null
+++ b/posthog/tasks/test/test_remote_config.py
@@ -0,0 +1,31 @@
+from posthog.models.project import Project
+from posthog.models.remote_config import RemoteConfig
+from posthog.tasks.remote_config import sync_all_remote_configs
+from posthog.test.base import BaseTest
+
+
+class TestRemoteConfig(BaseTest):
+    def setUp(self) -> None:
+        super().setUp()
+        project, team = Project.objects.create_with_team(
+            initiating_user=self.user,
+            organization=self.organization,
+            name="Test project",
+        )
+        self.other_team = team
+
+    def test_sync_task_syncs_all_remote_configs(self) -> None:
+        # Delete one teams config
+        RemoteConfig.objects.get(team=self.other_team).delete()
+        configs = RemoteConfig.objects.all()
+        assert len(configs) == 1
+
+        last_synced_at = RemoteConfig.objects.get(team=self.team).synced_at
+
+        sync_all_remote_configs()
+
+        configs = RemoteConfig.objects.all()
+        assert len(configs) == 2
+
+        assert RemoteConfig.objects.get(team=self.other_team).synced_at > last_synced_at  # type: ignore
+        assert RemoteConfig.objects.get(team=self.team).synced_at > last_synced_at  # type: ignore
diff --git a/posthog/tasks/test/test_usage_report.py b/posthog/tasks/test/test_usage_report.py
index ca5a46af1f914..a0c14a08a82d0 100644
--- a/posthog/tasks/test/test_usage_report.py
+++ b/posthog/tasks/test/test_usage_report.py
@@ -50,6 +50,7 @@
     APIBaseTest,
     ClickhouseDestroyTablesMixin,
     ClickhouseTestMixin,
+    QueryMatchingTest,
     _create_event,
     _create_person,
     also_test_with_materialized_columns,
@@ -140,7 +141,7 @@ def _setup_replay_data(team_id: int, include_mobile_replay: bool) -> None:
 
 
 @freeze_time("2022-01-10T00:01:00Z")
-class UsageReport(APIBaseTest, ClickhouseTestMixin, ClickhouseDestroyTablesMixin):
+class UsageReport(APIBaseTest, ClickhouseTestMixin, ClickhouseDestroyTablesMixin, QueryMatchingTest):
     def setUp(self) -> None:
         super().setUp()
 
@@ -1600,11 +1601,11 @@ def test_capture_event_called_with_string_timestamp(self, mock_client: MagicMock
         mock_posthog = MagicMock()
         mock_client.return_value = mock_posthog
         capture_event(
-            mock_client,
-            "test event",
-            organization.id,
-            {"prop1": "val1"},
-            "2021-10-10T23:01:00.00Z",
+            pha_client=mock_client,
+            name="test event",
+            organization_id=organization.id,
+            properties={"prop1": "val1"},
+            timestamp="2021-10-10T23:01:00.00Z",
         )
         assert mock_client.capture.call_args[1]["timestamp"] == datetime(2021, 10, 10, 23, 1, tzinfo=tzutc())
 
diff --git a/posthog/tasks/usage_report.py b/posthog/tasks/usage_report.py
index a2671bd97ebd5..41ca2d8c86f63 100644
--- a/posthog/tasks/usage_report.py
+++ b/posthog/tasks/usage_report.py
@@ -19,7 +19,6 @@
 
 from posthog import version_requirement
 from posthog.clickhouse.client.connection import Workload
-from posthog.clickhouse.materialized_columns import get_enabled_materialized_columns
 from posthog.client import sync_execute
 from posthog.cloud_utils import get_cached_instance_license, is_cloud
 from posthog.constants import FlagRequestType
@@ -29,6 +28,7 @@
 from posthog.models.feature_flag import FeatureFlag
 from posthog.models.organization import Organization
 from posthog.models.plugin import PluginConfig
+from posthog.models.property.util import get_property_string_expr
 from posthog.models.team.team import Team
 from posthog.models.utils import namedtuplefetchall
 from posthog.settings import CLICKHOUSE_CLUSTER, INSTANCE_TAG
@@ -336,20 +336,23 @@ def send_report_to_billing_service(org_id: str, report: dict[str, Any]) -> None:
         capture_exception(err)
         pha_client = Client("sTMFPsFhdP1Ssg")
         capture_event(
-            pha_client,
-            f"organization usage report to billing service failure",
-            org_id,
-            {"err": str(err)},
+            pha_client=pha_client,
+            name=f"organization usage report to billing service failure",
+            organization_id=org_id,
+            properties={"err": str(err)},
         )
         raise
 
 
 def capture_event(
+    *,
     pha_client: Client,
     name: str,
-    organization_id: str,
+    organization_id: Optional[str] = None,
+    team_id: Optional[int] = None,
     properties: dict[str, Any],
     timestamp: Optional[Union[datetime, str]] = None,
+    send_for_all_members: bool = False,
 ) -> None:
     if timestamp and isinstance(timestamp, str):
         try:
@@ -357,16 +360,38 @@ def capture_event(
         except ValueError:
             timestamp = None
 
+    if not organization_id and not team_id:
+        raise ValueError("Either organization_id or team_id must be provided")
+
     if is_cloud():
-        org_owner = get_org_owner_or_first_user(organization_id)
-        distinct_id = org_owner.distinct_id if org_owner and org_owner.distinct_id else f"org-{organization_id}"
-        pha_client.capture(
-            distinct_id,
-            name,
-            {**properties, "scope": "user"},
-            groups={"organization": organization_id, "instance": settings.SITE_URL},
-            timestamp=timestamp,
-        )
+        distinct_ids = []
+        if send_for_all_members:
+            if organization_id:
+                distinct_ids = list(
+                    OrganizationMembership.objects.filter(organization_id=organization_id).values_list(
+                        "user__distinct_id", flat=True
+                    )
+                )
+            elif team_id:
+                team = Team.objects.get(id=team_id)
+                distinct_ids = [user.distinct_id for user in team.all_users_with_access()]
+        else:
+            if not organization_id:
+                team = Team.objects.get(id=team_id)
+                organization_id = team.organization_id
+            org_owner = get_org_owner_or_first_user(organization_id) if organization_id else None
+            distinct_ids.append(
+                org_owner.distinct_id if org_owner and org_owner.distinct_id else f"org-{organization_id}"
+            )
+
+        for distinct_id in distinct_ids:
+            pha_client.capture(
+                distinct_id,
+                name,
+                {**properties, "scope": "user"},
+                groups={"organization": organization_id, "instance": settings.SITE_URL},
+                timestamp=timestamp,
+            )
         pha_client.group_identify("organization", organization_id, properties)
     else:
         pha_client.capture(
@@ -460,10 +485,8 @@ def get_teams_with_event_count_with_groups_in_period(begin: datetime, end: datet
 @timed_log()
 @retry(tries=QUERY_RETRIES, delay=QUERY_RETRY_DELAY, backoff=QUERY_RETRY_BACKOFF)
 def get_all_event_metrics_in_period(begin: datetime, end: datetime) -> dict[str, list[tuple[int, int]]]:
-    materialized_columns = get_enabled_materialized_columns("events")
-
     # Check if $lib is materialized
-    lib_expression = materialized_columns.get(("$lib", "properties"), "JSONExtractString(properties, '$lib')")
+    lib_expression, _ = get_property_string_expr("events", "$lib", "'$lib'", "properties")
 
     results = sync_execute(
         f"""
@@ -712,20 +735,40 @@ def get_teams_with_hog_function_fetch_calls_in_period(
 
 @shared_task(**USAGE_REPORT_TASK_KWARGS, max_retries=0)
 def capture_report(
+    *,
     capture_event_name: str,
-    org_id: str,
+    org_id: Optional[str] = None,
+    team_id: Optional[int] = None,
     full_report_dict: dict[str, Any],
     at_date: Optional[datetime] = None,
+    send_for_all_members: bool = False,
 ) -> None:
+    if not org_id and not team_id:
+        raise ValueError("Either org_id or team_id must be provided")
     pha_client = Client("sTMFPsFhdP1Ssg")
     try:
-        capture_event(pha_client, capture_event_name, org_id, full_report_dict, timestamp=at_date)
+        capture_event(
+            pha_client=pha_client,
+            name=capture_event_name,
+            organization_id=org_id,
+            team_id=team_id,
+            properties=full_report_dict,
+            timestamp=at_date,
+            send_for_all_members=send_for_all_members,
+        )
         logger.info(f"UsageReport sent to PostHog for organization {org_id}")
     except Exception as err:
         logger.exception(
             f"UsageReport sent to PostHog for organization {org_id} failed: {str(err)}",
         )
-        capture_event(pha_client, f"{capture_event_name} failure", org_id, {"error": str(err)})
+        capture_event(
+            pha_client=pha_client,
+            name=f"{capture_event_name} failure",
+            organization_id=org_id,
+            team_id=team_id,
+            properties={"error": str(err)},
+            send_for_all_members=send_for_all_members,
+        )
     pha_client.flush()
 
 
@@ -938,7 +981,7 @@ def _get_teams_for_usage_reports() -> Sequence[Team]:
     return list(
         Team.objects.select_related("organization")
         .exclude(Q(organization__for_internal_metrics=True) | Q(is_demo=True))
-        .only("id", "organization__id", "organization__name", "organization__created_at")
+        .only("id", "name", "organization__id", "organization__name", "organization__created_at")
     )
 
 
@@ -1043,6 +1086,7 @@ def _get_all_org_reports(period_start: datetime, period_end: datetime) -> dict[s
     logger.info("Getting all usage data...")  # noqa T201
     time_now = datetime.now()
     all_data = _get_all_usage_data_as_team_rows(period_start, period_end)
+
     logger.debug(f"Getting all usage data took {(datetime.now() - time_now).total_seconds()} seconds.")  # noqa T201
 
     logger.info("Getting teams for usage reports...")  # noqa T201
@@ -1110,7 +1154,12 @@ def send_all_org_usage_reports(
             # First capture the events to PostHog
             if not skip_capture_event:
                 at_date_str = at_date.isoformat() if at_date else None
-                capture_report.delay(capture_event_name, org_id, full_report_dict, at_date_str)
+                capture_report.delay(
+                    capture_event_name=capture_event_name,
+                    org_id=org_id,
+                    full_report_dict=full_report_dict,
+                    at_date=at_date_str,
+                )
 
             # Then capture the events to Billing
             if has_non_zero_usage(full_report):
diff --git a/posthog/temporal/batch_exports/__init__.py b/posthog/temporal/batch_exports/__init__.py
index 33c1b200e6a97..a3616f1107c5b 100644
--- a/posthog/temporal/batch_exports/__init__.py
+++ b/posthog/temporal/batch_exports/__init__.py
@@ -17,6 +17,12 @@
     HttpBatchExportWorkflow,
     insert_into_http_activity,
 )
+from posthog.temporal.batch_exports.monitoring import (
+    BatchExportMonitoringWorkflow,
+    get_batch_export,
+    get_event_counts,
+    update_batch_export_runs,
+)
 from posthog.temporal.batch_exports.noop import NoOpWorkflow, noop_activity
 from posthog.temporal.batch_exports.postgres_batch_export import (
     PostgresBatchExportWorkflow,
@@ -54,6 +60,7 @@
     SnowflakeBatchExportWorkflow,
     HttpBatchExportWorkflow,
     SquashPersonOverridesWorkflow,
+    BatchExportMonitoringWorkflow,
 ]
 
 ACTIVITIES = [
@@ -76,4 +83,7 @@
     update_batch_export_backfill_model_status,
     wait_for_mutation,
     wait_for_table,
+    get_batch_export,
+    get_event_counts,
+    update_batch_export_runs,
 ]
diff --git a/posthog/temporal/batch_exports/bigquery_batch_export.py b/posthog/temporal/batch_exports/bigquery_batch_export.py
index ae5a7f58733c9..30c600d210802 100644
--- a/posthog/temporal/batch_exports/bigquery_batch_export.py
+++ b/posthog/temporal/batch_exports/bigquery_batch_export.py
@@ -8,6 +8,7 @@
 import pyarrow as pa
 import structlog
 from django.conf import settings
+from google.api_core.exceptions import Forbidden
 from google.cloud import bigquery
 from google.oauth2 import service_account
 from temporalio import activity, workflow
@@ -68,11 +69,21 @@
     # Raised when table_id isn't valid. Sadly, `ValueError` is rather generic, but we
     # don't anticipate a `ValueError` thrown from our own export code.
     "ValueError",
+    # Raised when attempting to run a batch export without required BigQuery permissions.
+    # Our own version of `Forbidden`.
+    "MissingRequiredPermissionsError",
 ]
 
 
+class MissingRequiredPermissionsError(Exception):
+    """Raised when missing required permissions in BigQuery."""
+
+    def __init__(self):
+        super().__init__("Missing required permissions to run this batch export")
+
+
 def get_bigquery_fields_from_record_schema(
-    record_schema: pa.Schema, known_json_columns: list[str]
+    record_schema: pa.Schema, known_json_columns: collections.abc.Sequence[str]
 ) -> list[bigquery.SchemaField]:
     """Generate a list of supported BigQuery fields from PyArrow schema.
 
@@ -154,6 +165,17 @@ class BigQueryInsertInputs:
     batch_export_schema: BatchExportSchema | None = None
 
 
+class BigQueryQuotaExceededError(Exception):
+    """Exception raised when a BigQuery quota is exceeded.
+
+    This error indicates that we have been exporting too much data and need to
+    slow down. This error is retryable.
+    """
+
+    def __init__(self, message: str):
+        super().__init__(f"A BigQuery quota has been exceeded. Error: {message}")
+
+
 class BigQueryClient(bigquery.Client):
     async def acreate_table(
         self,
@@ -225,7 +247,101 @@ async def managed_table(
             yield table
         finally:
             if delete is True:
-                await self.adelete_table(project_id, dataset_id, table_id, not_found_ok)
+                try:
+                    await self.adelete_table(project_id, dataset_id, table_id, not_found_ok)
+                except Forbidden:
+                    await logger.awarning(
+                        "Missing delete permissions to delete %s.%s.%s", project_id, dataset_id, table_id
+                    )
+
+    async def amerge_tables(
+        self,
+        final_table: bigquery.Table,
+        stage_table: bigquery.Table,
+        mutable: bool,
+        stage_fields_cast_to_json: collections.abc.Sequence[str] | None = None,
+        merge_key: collections.abc.Iterable[bigquery.SchemaField] | None = None,
+    ):
+        """Merge two tables in BigQuery.
+
+        When `mutable` is `False`, we will do a simple `INSERT INTO final FROM stage`,
+        whereas when `mutable` is `True` we will do the more complex `MERGE` query.
+        This is because inmutable tables do not need to concern themselves with
+        the conflict resolution options provided by `MERGE` as each row is unique.
+
+        Arguments:
+            final_table: The BigQuery table we are merging into.
+            stage_table: The BigQuery table we are merging from.
+            mutable: Whether the table is mutable and requires a merge, or not.
+            stage_fields_cast_to_json: Fields that must be cast to `JSON` from
+                `stage_table` when inserting them in `final_table`.
+            merge_key: If table is mutable, the merge key columns.
+        """
+        if mutable is False:
+            return await self.ainsert_into_from_stage_table(
+                final_table, stage_table, stage_fields_cast_to_json=stage_fields_cast_to_json
+            )
+        else:
+            if merge_key is None:
+                raise ValueError("Merge key must be defined when merging a mutable model")
+
+            return await self.amerge_person_tables(
+                final_table, stage_table, merge_key=merge_key, stage_fields_cast_to_json=stage_fields_cast_to_json
+            )
+
+    async def acheck_for_query_permissions_on_table(
+        self,
+        table: bigquery.Table,
+    ):
+        """Attempt to SELECT from table to check for query permissions."""
+        job_config = bigquery.QueryJobConfig()
+        if "timestamp" in [field.name for field in table.schema]:
+            query = f"""
+            SELECT 1 FROM  `{table.full_table_id.replace(":", ".", 1)}` WHERE timestamp IS NOT NULL
+            """
+        else:
+            query = f"""
+            SELECT 1 FROM  `{table.full_table_id.replace(":", ".", 1)}`
+            """
+
+        try:
+            query_job = self.query(query, job_config=job_config)
+            await asyncio.to_thread(query_job.result)
+        except Forbidden:
+            return False
+        return True
+
+    async def ainsert_into_from_stage_table(
+        self,
+        into_table: bigquery.Table,
+        stage_table: bigquery.Table,
+        stage_fields_cast_to_json: collections.abc.Sequence[str] | None = None,
+    ):
+        """Insert data from `stage_table` into `into_table`."""
+        job_config = bigquery.QueryJobConfig()
+        into_table_fields = ",".join(f"`{field.name}`" for field in into_table.schema)
+
+        if stage_fields_cast_to_json is not None:
+            fields_to_cast = set(stage_fields_cast_to_json)
+        else:
+            fields_to_cast = set()
+        stage_table_fields = ",".join(
+            f"PARSE_JSON(`{field.name}`, wide_number_mode=>'round')"
+            if field.name in fields_to_cast
+            else f"`{field.name}`"
+            for field in into_table.schema
+        )
+
+        query = f"""
+        INSERT INTO `{into_table.full_table_id.replace(":", ".", 1)}`
+          ({into_table_fields})
+        SELECT
+          {stage_table_fields}
+        FROM `{stage_table.full_table_id.replace(":", ".", 1)}`
+        """
+
+        query_job = self.query(query, job_config=job_config)
+        return await asyncio.to_thread(query_job.result)
 
     async def amerge_person_tables(
         self,
@@ -234,10 +350,16 @@ async def amerge_person_tables(
         merge_key: collections.abc.Iterable[bigquery.SchemaField],
         person_version_key: str = "person_version",
         person_distinct_id_version_key: str = "person_distinct_id_version",
+        stage_fields_cast_to_json: collections.abc.Sequence[str] | None = None,
     ):
         """Merge two identical person model tables in BigQuery."""
         job_config = bigquery.QueryJobConfig()
 
+        if stage_fields_cast_to_json is not None:
+            fields_to_cast = set(stage_fields_cast_to_json)
+        else:
+            fields_to_cast = set()
+
         merge_condition = "ON "
 
         for n, field in enumerate(merge_key):
@@ -255,16 +377,31 @@ async def amerge_person_tables(
                 values += ", "
                 field_names += ", "
 
-            update_clause += f"final.`{field.name}` = stage.`{field.name}`"
+            stage_field = (
+                f"PARSE_JSON(stage.`{field.name}`, wide_number_mode=>'round')"
+                if field.name in fields_to_cast
+                else f"stage.`{field.name}`"
+            )
+            update_clause += f"final.`{field.name}` = {stage_field}"
             field_names += f"`{field.name}`"
-            values += f"stage.`{field.name}`"
+            values += stage_field
 
         if not update_clause:
             raise ValueError("Empty update clause")
 
         merge_query = f"""
         MERGE `{final_table.full_table_id.replace(":", ".", 1)}` final
-        USING `{stage_table.full_table_id.replace(":", ".", 1)}` stage
+        USING (
+            SELECT * FROM
+            (
+              SELECT
+              *,
+              ROW_NUMBER() OVER (PARTITION BY {",".join(field.name for field in merge_key)}) row_num
+            FROM
+              `{stage_table.full_table_id.replace(":", ".", 1)}`
+            )
+            WHERE row_num = 1
+        ) stage
         {merge_condition}
 
         WHEN MATCHED AND (stage.`{person_version_key}` > final.`{person_version_key}` OR stage.`{person_distinct_id_version_key}` > final.`{person_distinct_id_version_key}`) THEN
@@ -290,11 +427,23 @@ async def load_parquet_file(self, parquet_file, table, table_schema):
             self.load_table_from_file, parquet_file, table, job_config=job_config, rewind=True
         )
         await logger.adebug("Waiting for BigQuery load job for Parquet file '%s'", parquet_file)
-        result = await asyncio.to_thread(load_job.result)
+
+        try:
+            result = await asyncio.to_thread(load_job.result)
+        except Forbidden as err:
+            if err.reason == "quotaExceeded":
+                raise BigQueryQuotaExceededError(err.message) from err
+            raise
+
         return result
 
     async def load_jsonl_file(self, jsonl_file, table, table_schema):
-        """Execute a COPY FROM query with given connection to copy contents of jsonl_file."""
+        """Execute a COPY FROM query to copy contents of `jsonl_file`.
+
+        Raises:
+            BigQueryQuotaExceededError: If we receive a 'quotaExceeded' error from
+                BigQuery when loading a file.
+        """
         job_config = bigquery.LoadJobConfig(
             source_format="NEWLINE_DELIMITED_JSON",
             schema=table_schema,
@@ -304,9 +453,15 @@ async def load_jsonl_file(self, jsonl_file, table, table_schema):
         load_job = await asyncio.to_thread(
             self.load_table_from_file, jsonl_file, table, job_config=job_config, rewind=True
         )
-
         await logger.adebug("Waiting for BigQuery load job for JSONL file '%s'", jsonl_file)
-        result = await asyncio.to_thread(load_job.result)
+
+        try:
+            result = await asyncio.to_thread(load_job.result)
+        except Forbidden as err:
+            if err.reason == "quotaExceeded":
+                raise BigQueryQuotaExceededError(err.message) from err
+            raise
+
         return result
 
 
@@ -364,11 +519,12 @@ def __init__(
         heartbeater: Heartbeater,
         heartbeat_details: BigQueryHeartbeatDetails,
         data_interval_start: dt.datetime | str | None,
+        writer_format: WriterFormat,
         bigquery_client: BigQueryClient,
         bigquery_table: bigquery.Table,
         table_schema: list[BatchExportField],
     ):
-        super().__init__(heartbeater, heartbeat_details, data_interval_start)
+        super().__init__(heartbeater, heartbeat_details, data_interval_start, writer_format)
         self.bigquery_client = bigquery_client
         self.bigquery_table = bigquery_table
         self.table_schema = table_schema
@@ -391,7 +547,10 @@ async def flush(
             self.bigquery_table,
         )
 
-        await self.bigquery_client.load_jsonl_file(batch_export_file, self.bigquery_table, self.table_schema)
+        if self.writer_format == WriterFormat.PARQUET:
+            await self.bigquery_client.load_parquet_file(batch_export_file, self.bigquery_table, self.table_schema)
+        else:
+            await self.bigquery_client.load_jsonl_file(batch_export_file, self.bigquery_table, self.table_schema)
 
         await self.logger.adebug("Loaded %s to BigQuery table '%s'", records_since_last_flush, self.bigquery_table)
         self.rows_exported_counter.add(records_since_last_flush)
@@ -484,7 +643,6 @@ async def insert_into_bigquery_activity(inputs: BigQueryInsertInputs) -> Records
             # between batches.
             [field.with_nullable(True) for field in record_batch_schema if field.name != "_inserted_at"]
         )
-
         if inputs.use_json_type is True:
             json_type = "JSON"
             json_columns = ["properties", "set", "set_once", "person_properties"]
@@ -510,63 +668,70 @@ async def insert_into_bigquery_activity(inputs: BigQueryInsertInputs) -> Records
         else:
             schema = get_bigquery_fields_from_record_schema(record_batch_schema, known_json_columns=json_columns)
 
-        # TODO: Expose this as a configuration parameter
-        # Currently, only allow merging persons model, as it's required.
-        # Although all exports could potentially benefit from merging, merging can have an impact on cost,
-        # so users should decide whether to opt-in or not.
-        requires_merge = (
-            isinstance(inputs.batch_export_model, BatchExportModel) and inputs.batch_export_model.name == "persons"
-        )
+        stage_schema = [
+            bigquery.SchemaField(field.name, "STRING") if field.name in json_columns else field for field in schema
+        ]
         data_interval_end_str = dt.datetime.fromisoformat(inputs.data_interval_end).strftime("%Y-%m-%d_%H-%M-%S")
-        stage_table_name = f"stage_{inputs.table_id}_{data_interval_end_str}" if requires_merge else inputs.table_id
+        stage_table_name = f"stage_{inputs.table_id}_{data_interval_end_str}"
 
         with bigquery_client(inputs) as bq_client:
-            async with (
-                bq_client.managed_table(
-                    project_id=inputs.project_id,
-                    dataset_id=inputs.dataset_id,
-                    table_id=inputs.table_id,
-                    table_schema=schema,
-                    delete=False,
-                ) as bigquery_table,
-                bq_client.managed_table(
+            async with bq_client.managed_table(
+                project_id=inputs.project_id,
+                dataset_id=inputs.dataset_id,
+                table_id=inputs.table_id,
+                table_schema=schema,
+                delete=False,
+            ) as bigquery_table:
+                can_perform_merge = await bq_client.acheck_for_query_permissions_on_table(bigquery_table)
+
+                if not can_perform_merge:
+                    if model_name == "persons":
+                        raise MissingRequiredPermissionsError()
+
+                    await logger.awarning(
+                        "Missing query permissions on BigQuery table required for merging, will attempt direct load into final table"
+                    )
+
+                async with bq_client.managed_table(
                     project_id=inputs.project_id,
                     dataset_id=inputs.dataset_id,
-                    table_id=stage_table_name,
-                    table_schema=schema,
-                    create=requires_merge,
-                    delete=requires_merge,
-                ) as bigquery_stage_table,
-            ):
-                records_completed = await run_consumer_loop(
-                    queue=queue,
-                    consumer_cls=BigQueryConsumer,
-                    producer_task=producer_task,
-                    heartbeater=heartbeater,
-                    heartbeat_details=details,
-                    data_interval_end=data_interval_end,
-                    data_interval_start=data_interval_start,
-                    schema=record_batch_schema,
-                    writer_format=WriterFormat.JSONL,
-                    max_bytes=settings.BATCH_EXPORT_BIGQUERY_UPLOAD_CHUNK_SIZE_BYTES,
-                    non_retryable_error_types=NON_RETRYABLE_ERROR_TYPES,
-                    json_columns=json_columns,
-                    bigquery_client=bq_client,
-                    bigquery_table=bigquery_stage_table if requires_merge else bigquery_table,
-                    table_schema=schema,
-                )
-
-                if requires_merge:
-                    merge_key = (
-                        bigquery.SchemaField("team_id", "INT64"),
-                        bigquery.SchemaField("distinct_id", "STRING"),
-                    )
-                    await bq_client.amerge_person_tables(
-                        final_table=bigquery_table,
-                        stage_table=bigquery_stage_table,
-                        merge_key=merge_key,
+                    table_id=stage_table_name if can_perform_merge else inputs.table_id,
+                    table_schema=stage_schema,
+                    create=can_perform_merge,
+                    delete=can_perform_merge,
+                ) as bigquery_stage_table:
+                    records_completed = await run_consumer_loop(
+                        queue=queue,
+                        consumer_cls=BigQueryConsumer,
+                        producer_task=producer_task,
+                        heartbeater=heartbeater,
+                        heartbeat_details=details,
+                        data_interval_end=data_interval_end,
+                        data_interval_start=data_interval_start,
+                        schema=record_batch_schema,
+                        writer_format=WriterFormat.PARQUET if can_perform_merge else WriterFormat.JSONL,
+                        max_bytes=settings.BATCH_EXPORT_BIGQUERY_UPLOAD_CHUNK_SIZE_BYTES,
+                        json_columns=() if can_perform_merge else json_columns,
+                        bigquery_client=bq_client,
+                        bigquery_table=bigquery_stage_table if can_perform_merge else bigquery_table,
+                        table_schema=stage_schema if can_perform_merge else schema,
+                        writer_file_kwargs={"compression": "zstd"} if can_perform_merge else {},
+                        multiple_files=True,
                     )
 
+                    if can_perform_merge:
+                        merge_key = (
+                            bigquery.SchemaField("team_id", "INT64"),
+                            bigquery.SchemaField("distinct_id", "STRING"),
+                        )
+                        await bq_client.amerge_tables(
+                            final_table=bigquery_table,
+                            stage_table=bigquery_stage_table,
+                            mutable=True if model_name == "persons" else False,
+                            merge_key=merge_key,
+                            stage_fields_cast_to_json=json_columns,
+                        )
+
         return records_completed
 
 
@@ -647,4 +812,5 @@ async def run(self, inputs: BigQueryBatchExportInputs):
             interval=inputs.interval,
             non_retryable_error_types=NON_RETRYABLE_ERROR_TYPES,
             finish_inputs=finish_inputs,
+            maximum_retry_interval_seconds=240,
         )
diff --git a/posthog/temporal/batch_exports/monitoring.py b/posthog/temporal/batch_exports/monitoring.py
new file mode 100644
index 0000000000000..97eaf6c2430d9
--- /dev/null
+++ b/posthog/temporal/batch_exports/monitoring.py
@@ -0,0 +1,227 @@
+import datetime as dt
+import json
+from dataclasses import dataclass
+from uuid import UUID
+
+from temporalio import activity, workflow
+from temporalio.common import RetryPolicy
+
+from posthog.batch_exports.models import BatchExport
+from posthog.batch_exports.service import aupdate_records_total_count
+from posthog.batch_exports.sql import EVENT_COUNT_BY_INTERVAL
+from posthog.temporal.batch_exports.base import PostHogWorkflow
+from posthog.temporal.common.clickhouse import get_client
+from posthog.temporal.common.heartbeat import Heartbeater
+
+
+class BatchExportNotFoundError(Exception):
+    """Exception raised when batch export is not found."""
+
+    def __init__(self, batch_export_id: UUID):
+        super().__init__(f"Batch export with id {batch_export_id} not found")
+
+
+class NoValidBatchExportsFoundError(Exception):
+    """Exception raised when no valid batch export is found."""
+
+    def __init__(self, message: str = "No valid batch exports found"):
+        super().__init__(message)
+
+
+@dataclass
+class BatchExportMonitoringInputs:
+    """Inputs for the BatchExportMonitoringWorkflow.
+
+    Attributes:
+        batch_export_id: The batch export id to monitor.
+    """
+
+    batch_export_id: UUID
+
+
+@dataclass
+class BatchExportDetails:
+    id: UUID
+    team_id: int
+    interval: str
+    exclude_events: list[str]
+    include_events: list[str]
+
+
+@activity.defn
+async def get_batch_export(batch_export_id: UUID) -> BatchExportDetails:
+    """Fetch a batch export from the database and return its details."""
+    batch_export = (
+        await BatchExport.objects.filter(id=batch_export_id, model="events", paused=False, deleted=False)
+        .prefetch_related("destination")
+        .afirst()
+    )
+    if batch_export is None:
+        raise BatchExportNotFoundError(batch_export_id)
+    if batch_export.deleted is True:
+        raise NoValidBatchExportsFoundError("Batch export has been deleted")
+    if batch_export.paused is True:
+        raise NoValidBatchExportsFoundError("Batch export is paused")
+    if batch_export.model != "events":
+        raise NoValidBatchExportsFoundError("Batch export model is not 'events'")
+    if batch_export.interval_time_delta != dt.timedelta(minutes=5):
+        raise NoValidBatchExportsFoundError(
+            "Only batch exports with interval of 5 minutes are supported for monitoring at this time."
+        )
+    config = batch_export.destination.config
+    return BatchExportDetails(
+        id=batch_export.id,
+        team_id=batch_export.team_id,
+        interval=batch_export.interval,
+        exclude_events=config.get("exclude_events", []),
+        include_events=config.get("include_events", []),
+    )
+
+
+@dataclass
+class GetEventCountsInputs:
+    team_id: int
+    interval: str
+    overall_interval_start: str
+    overall_interval_end: str
+    exclude_events: list[str]
+    include_events: list[str]
+
+
+@dataclass
+class EventCountsOutput:
+    interval_start: str
+    interval_end: str
+    count: int
+
+
+@dataclass
+class GetEventCountsOutputs:
+    results: list[EventCountsOutput]
+
+
+@activity.defn
+async def get_event_counts(inputs: GetEventCountsInputs) -> GetEventCountsOutputs:
+    """Get the total number of events for a given team over a set of time intervals."""
+
+    query = EVENT_COUNT_BY_INTERVAL
+
+    interval = inputs.interval
+    # we check interval is "every 5 minutes" above but double check here
+    if not interval.startswith("every 5 minutes"):
+        raise NoValidBatchExportsFoundError(
+            "Only intervals of 'every 5 minutes' are supported for monitoring at this time."
+        )
+    _, value, unit = interval.split(" ")
+    interval = f"{value} {unit}"
+
+    query_params = {
+        "team_id": inputs.team_id,
+        "interval": interval,
+        "overall_interval_start": inputs.overall_interval_start,
+        "overall_interval_end": inputs.overall_interval_end,
+        "include_events": inputs.include_events,
+        "exclude_events": inputs.exclude_events,
+    }
+    async with Heartbeater(), get_client() as client:
+        if not await client.is_alive():
+            raise ConnectionError("Cannot establish connection to ClickHouse")
+
+        response = await client.read_query(query, query_params)
+        results = []
+        for line in response.decode("utf-8").splitlines():
+            interval_start, interval_end, count = line.strip().split("\t")
+            results.append(
+                EventCountsOutput(interval_start=interval_start, interval_end=interval_end, count=int(count))
+            )
+
+        return GetEventCountsOutputs(results=results)
+
+
+@dataclass
+class UpdateBatchExportRunsInputs:
+    batch_export_id: UUID
+    results: list[EventCountsOutput]
+
+
+@activity.defn
+async def update_batch_export_runs(inputs: UpdateBatchExportRunsInputs) -> int:
+    """Update BatchExportRuns with the expected number of events."""
+
+    total_rows_updated = 0
+    async with Heartbeater():
+        for result in inputs.results:
+            total_rows_updated += await aupdate_records_total_count(
+                batch_export_id=inputs.batch_export_id,
+                interval_start=dt.datetime.strptime(result.interval_start, "%Y-%m-%d %H:%M:%S").replace(tzinfo=dt.UTC),
+                interval_end=dt.datetime.strptime(result.interval_end, "%Y-%m-%d %H:%M:%S").replace(tzinfo=dt.UTC),
+                count=result.count,
+            )
+    activity.logger.info(f"Updated {total_rows_updated} BatchExportRuns")
+    return total_rows_updated
+
+
+@workflow.defn(name="batch-export-monitoring")
+class BatchExportMonitoringWorkflow(PostHogWorkflow):
+    """Workflow to monitor batch exports.
+
+    We have had some issues with batch exports in the past, where some events
+    have been missing. The purpose of this workflow is to monitor the status of
+    batch exports for a given customer by reconciling the number of exported
+    events with the number of events in ClickHouse for a given interval.
+    """
+
+    @staticmethod
+    def parse_inputs(inputs: list[str]) -> BatchExportMonitoringInputs:
+        """Parse inputs from the management command CLI."""
+        loaded = json.loads(inputs[0])
+        return BatchExportMonitoringInputs(**loaded)
+
+    @workflow.run
+    async def run(self, inputs: BatchExportMonitoringInputs):
+        """Workflow implementation to monitor batch exports for a given team."""
+        # TODO - check if this is the right way to do logging since there seems to be a few different ways
+        workflow.logger.info(
+            "Starting batch exports monitoring workflow for batch export id %s", inputs.batch_export_id
+        )
+
+        batch_export_details = await workflow.execute_activity(
+            get_batch_export,
+            inputs.batch_export_id,
+            start_to_close_timeout=dt.timedelta(minutes=1),
+            retry_policy=RetryPolicy(
+                initial_interval=dt.timedelta(seconds=20),
+                non_retryable_error_types=["BatchExportNotFoundError", "NoValidBatchExportsFoundError"],
+            ),
+        )
+
+        # time interval to check is not the previous hour but the hour before that
+        # (just to ensure all recent batch exports have run successfully)
+        now = dt.datetime.now(tz=dt.UTC)
+        interval_end = now.replace(minute=0, second=0, microsecond=0) - dt.timedelta(hours=1)
+        interval_start = interval_end - dt.timedelta(hours=1)
+        interval_end_str = interval_end.strftime("%Y-%m-%d %H:%M:%S")
+        interval_start_str = interval_start.strftime("%Y-%m-%d %H:%M:%S")
+
+        total_events = await workflow.execute_activity(
+            get_event_counts,
+            GetEventCountsInputs(
+                team_id=batch_export_details.team_id,
+                interval=batch_export_details.interval,
+                overall_interval_start=interval_start_str,
+                overall_interval_end=interval_end_str,
+                exclude_events=batch_export_details.exclude_events,
+                include_events=batch_export_details.include_events,
+            ),
+            start_to_close_timeout=dt.timedelta(hours=1),
+            retry_policy=RetryPolicy(maximum_attempts=3, initial_interval=dt.timedelta(seconds=20)),
+            heartbeat_timeout=dt.timedelta(minutes=1),
+        )
+
+        return await workflow.execute_activity(
+            update_batch_export_runs,
+            UpdateBatchExportRunsInputs(batch_export_id=batch_export_details.id, results=total_events.results),
+            start_to_close_timeout=dt.timedelta(hours=1),
+            retry_policy=RetryPolicy(maximum_attempts=3, initial_interval=dt.timedelta(seconds=20)),
+            heartbeat_timeout=dt.timedelta(minutes=1),
+        )
diff --git a/posthog/temporal/batch_exports/s3_batch_export.py b/posthog/temporal/batch_exports/s3_batch_export.py
index 7201af91d2b5a..d6e95ee28fc22 100644
--- a/posthog/temporal/batch_exports/s3_batch_export.py
+++ b/posthog/temporal/batch_exports/s3_batch_export.py
@@ -51,9 +51,7 @@
     BatchExportTemporaryFile,
     WriterFormat,
 )
-from posthog.temporal.batch_exports.utils import (
-    set_status_to_running_task,
-)
+from posthog.temporal.batch_exports.utils import set_status_to_running_task
 from posthog.temporal.common.clickhouse import get_client
 from posthog.temporal.common.heartbeat import Heartbeater
 from posthog.temporal.common.logger import bind_temporal_worker_logger
@@ -67,12 +65,12 @@
     "NoSuchBucket",
     # Couldn't connect to custom S3 endpoint
     "EndpointConnectionError",
-    # Input contained an empty S3 endpoint URL
-    "EmptyS3EndpointURLError",
     # User provided an invalid S3 key
     "InvalidS3Key",
     # All consumers failed with non-retryable errors.
     "RecordBatchConsumerNonRetryableExceptionGroup",
+    # Invalid S3 endpoint URL
+    "InvalidS3EndpointError",
 ]
 
 FILE_FORMAT_EXTENSIONS = {
@@ -159,11 +157,11 @@ def __init__(self, part_number: int):
         super().__init__(f"An intermittent `RequestTimeout` was raised while attempting to upload part {part_number}")
 
 
-class EmptyS3EndpointURLError(Exception):
-    """Exception raised when an S3 endpoint URL is empty string."""
+class InvalidS3EndpointError(Exception):
+    """Exception raised when an S3 endpoint is invalid."""
 
-    def __init__(self):
-        super().__init__("Endpoint URL cannot be empty.")
+    def __init__(self, message: str = "Endpoint URL is invalid."):
+        super().__init__(message)
 
 
 Part = dict[str, str | int]
@@ -215,7 +213,7 @@ def __init__(
         self.pending_parts: list[Part] = []
 
         if self.endpoint_url == "":
-            raise EmptyS3EndpointURLError()
+            raise InvalidS3EndpointError("Endpoint URL is empty.")
 
     def to_state(self) -> S3MultiPartUploadState:
         """Produce state tuple that can be used to resume this S3MultiPartUpload."""
@@ -240,14 +238,19 @@ def is_upload_in_progress(self) -> bool:
     async def s3_client(self):
         """Asynchronously yield an S3 client."""
 
-        async with self._session.client(
-            "s3",
-            region_name=self.region_name,
-            aws_access_key_id=self.aws_access_key_id,
-            aws_secret_access_key=self.aws_secret_access_key,
-            endpoint_url=self.endpoint_url,
-        ) as client:
-            yield client
+        try:
+            async with self._session.client(
+                "s3",
+                region_name=self.region_name,
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                endpoint_url=self.endpoint_url,
+            ) as client:
+                yield client
+        except ValueError as err:
+            if "Invalid endpoint" in str(err):
+                raise InvalidS3EndpointError(str(err)) from err
+            raise
 
     async def start(self) -> str:
         """Start this S3MultiPartUpload."""
@@ -466,9 +469,10 @@ def __init__(
         heartbeater: Heartbeater,
         heartbeat_details: S3HeartbeatDetails,
         data_interval_start: dt.datetime | str | None,
+        writer_format: WriterFormat,
         s3_upload: S3MultiPartUpload,
     ):
-        super().__init__(heartbeater, heartbeat_details, data_interval_start)
+        super().__init__(heartbeater, heartbeat_details, data_interval_start, writer_format)
         self.heartbeat_details: S3HeartbeatDetails = heartbeat_details
         self.s3_upload = s3_upload
 
@@ -712,7 +716,6 @@ async def insert_into_s3_activity(inputs: S3InsertInputs) -> RecordsCompleted:
                 max_bytes=settings.BATCH_EXPORT_S3_UPLOAD_CHUNK_SIZE_BYTES,
                 s3_upload=s3_upload,
                 writer_file_kwargs={"compression": inputs.compression},
-                non_retryable_error_types=NON_RETRYABLE_ERROR_TYPES,
             )
 
             await s3_upload.complete()
diff --git a/posthog/temporal/batch_exports/spmc.py b/posthog/temporal/batch_exports/spmc.py
index 34a503646a3e4..253935656b1e7 100644
--- a/posthog/temporal/batch_exports/spmc.py
+++ b/posthog/temporal/batch_exports/spmc.py
@@ -175,11 +175,13 @@ def __init__(
         heartbeater: Heartbeater,
         heartbeat_details: BatchExportRangeHeartbeatDetails,
         data_interval_start: dt.datetime | str | None,
+        writer_format: WriterFormat,
     ):
         self.flush_start_event = asyncio.Event()
         self.heartbeater = heartbeater
         self.heartbeat_details = heartbeat_details
         self.data_interval_start = data_interval_start
+        self.writer_format = writer_format
         self.logger = logger
 
     @property
@@ -223,10 +225,10 @@ async def start(
         self,
         queue: RecordBatchQueue,
         producer_task: asyncio.Task,
-        writer_format: WriterFormat,
         max_bytes: int,
         schema: pa.Schema,
         json_columns: collections.abc.Sequence[str],
+        multiple_files: bool = False,
         **kwargs,
     ) -> int:
         """Start consuming record batches from queue.
@@ -234,49 +236,73 @@ async def start(
         Record batches will be written to a temporary file defined by `writer_format`
         and the file will be flushed upon reaching at least `max_bytes`.
 
+        Callers can control whether a new file is created for each flush or whether we
+        continue flushing to the same file by setting `multiple_files`. File data is
+        reset regardless, so this is not meant to impact total file size, but rather
+        to control whether we are exporting a single large file in multiple parts, or
+        multiple files that must each individually be valid.
+
         Returns:
             Total number of records in all consumed record batches.
         """
         await logger.adebug("Starting record batch consumer")
 
         schema = cast_record_batch_schema_json_columns(schema, json_columns=json_columns)
-        writer = get_batch_export_writer(writer_format, self.flush, schema=schema, max_bytes=max_bytes, **kwargs)
+        writer = get_batch_export_writer(self.writer_format, self.flush, schema=schema, max_bytes=max_bytes, **kwargs)
 
         record_batches_count = 0
+        records_count = 0
 
-        async with writer.open_temporary_file():
-            await self.logger.adebug("Starting record batch writing loop")
-            while True:
-                try:
-                    record_batch = queue.get_nowait()
-                    record_batches_count += 1
-                except asyncio.QueueEmpty:
-                    if producer_task.done():
-                        await self.logger.adebug(
-                            "Empty queue with no more events being produced, closing writer loop and flushing"
-                        )
-                        self.flush_start_event.set()
-                        # Exit context manager to trigger flush
-                        break
-                    else:
-                        await asyncio.sleep(0.1)
-                        continue
-
-                record_batch = cast_record_batch_json_columns(record_batch, json_columns=json_columns)
-                await writer.write_record_batch(record_batch, flush=False)
-
-                if writer.should_flush():
-                    await self.logger.adebug("Writer finished, ready to flush events")
-                    self.flush_start_event.set()
-                    # Exit context manager to trigger flush
-                    break
+        await self.logger.adebug("Starting record batch writing loop")
 
-        for _ in range(record_batches_count):
-            queue.task_done()
+        writer._batch_export_file = await asyncio.to_thread(writer.create_temporary_file)
 
-        await self.logger.adebug("Consumed %s records", writer.records_total)
+        async for record_batch in self.generate_record_batches_from_queue(queue, producer_task):
+            record_batches_count += 1
+            record_batch = cast_record_batch_json_columns(record_batch, json_columns=json_columns)
+
+            await writer.write_record_batch(record_batch, flush=False)
+
+            if writer.should_flush():
+                records_count += writer.records_since_last_flush
+
+                if multiple_files:
+                    await writer.close_temporary_file()
+                    writer._batch_export_file = await asyncio.to_thread(writer.create_temporary_file)
+                else:
+                    await writer.flush()
+
+                for _ in range(record_batches_count):
+                    queue.task_done()
+                record_batches_count = 0
+
+        records_count += writer.records_since_last_flush
+        await writer.close_temporary_file()
+
+        await self.logger.adebug("Consumed %s records", records_count)
         self.heartbeater.set_from_heartbeat_details(self.heartbeat_details)
-        return writer.records_total
+        return records_count
+
+    async def generate_record_batches_from_queue(
+        self,
+        queue: RecordBatchQueue,
+        producer_task: asyncio.Task,
+    ):
+        """Yield record batches from provided `queue` until `producer_task` is done."""
+        while True:
+            try:
+                record_batch = queue.get_nowait()
+            except asyncio.QueueEmpty:
+                if producer_task.done():
+                    await self.logger.adebug(
+                        "Empty queue with no more events being produced, closing writer loop and flushing"
+                    )
+                    break
+                else:
+                    await asyncio.sleep(0)
+                    continue
+
+            yield record_batch
 
 
 class RecordBatchConsumerRetryableExceptionGroup(ExceptionGroup):
@@ -306,7 +332,7 @@ async def run_consumer_loop(
     max_bytes: int,
     json_columns: collections.abc.Sequence[str] = ("properties", "person_properties", "set", "set_once"),
     writer_file_kwargs: collections.abc.Mapping[str, typing.Any] | None = None,
-    non_retryable_error_types: collections.abc.Sequence[str] = (),
+    multiple_files: bool = False,
     **kwargs,
 ) -> int:
     """Run record batch consumers in a loop.
@@ -344,68 +370,33 @@ def consumer_done_callback(task: asyncio.Task):
         consumer_tasks_done.add(task)
 
     await logger.adebug("Starting record batch consumer loop")
-    while not queue.empty() or not producer_task.done():
-        consumer = consumer_cls(heartbeater, heartbeat_details, data_interval_start, **kwargs)
-        consumer_task = asyncio.create_task(
-            consumer.start(
-                queue=queue,
-                producer_task=producer_task,
-                writer_format=writer_format,
-                max_bytes=max_bytes,
-                schema=schema,
-                json_columns=json_columns,
-                **writer_file_kwargs or {},
-            ),
-            name=f"record_batch_consumer_{consumer_number}",
-        )
-        consumer_tasks_pending.add(consumer_task)
-        consumer_task.add_done_callback(consumer_done_callback)
-        consumer_number += 1
-
-        while not consumer.flush_start_event.is_set() and not consumer_task.done():
-            # Block until we either start flushing or we are done consuming.
-            # Flush start should always happen first unless the consumer task fails.
-            await asyncio.sleep(0)
 
-        if consumer_task.done():
-            consumer_task_exception = consumer_task.exception()
+    consumer = consumer_cls(heartbeater, heartbeat_details, data_interval_start, writer_format, **kwargs)
+    consumer_task = asyncio.create_task(
+        consumer.start(
+            queue=queue,
+            producer_task=producer_task,
+            max_bytes=max_bytes,
+            schema=schema,
+            json_columns=json_columns,
+            multiple_files=multiple_files,
+            **writer_file_kwargs or {},
+        ),
+        name=f"record_batch_consumer_{consumer_number}",
+    )
+    consumer_tasks_pending.add(consumer_task)
+    consumer_task.add_done_callback(consumer_done_callback)
+    consumer_number += 1
 
-            if consumer_task_exception is not None:
-                raise consumer_task_exception
+    await asyncio.wait([consumer_task])
 
-    await logger.adebug("Finished producing, now waiting on any pending consumer tasks")
-    if consumer_tasks_pending:
-        await asyncio.wait(consumer_tasks_pending)
+    if consumer_task.done():
+        consumer_task_exception = consumer_task.exception()
 
-    retryable = []
-    non_retryable = []
-    for task in consumer_tasks_done:
-        try:
-            await raise_on_task_failure(task)
-
-        except Exception as e:
-            # TODO: Handle exception types instead of checking for exception names.
-            # We are losing some precision by not handling exception types with
-            # `except`, but using a sequence of strings keeps us in line with
-            # Temporal. Not a good reason though, but right now we would need to
-            # search for a handful of exception types, so this is a quicker tradeoff
-            # as we already have the list of strings for each destination.
-            if e.__class__.__name__ in non_retryable_error_types:
-                await logger.aexception("Consumer task %s has failed with a non-retryable %s", task, e, exc_info=e)
-                non_retryable.append(e)
+        if consumer_task_exception is not None:
+            raise consumer_task_exception
 
-            else:
-                await logger.aexception("Consumer task %s has failed with a retryable %s", task, e, exc_info=e)
-                retryable.append(e)
-
-    if retryable:
-        raise RecordBatchConsumerRetryableExceptionGroup(
-            "At least one unhandled retryable errors in a RecordBatch consumer TaskGroup", retryable + non_retryable
-        )
-    elif non_retryable:
-        raise RecordBatchConsumerNonRetryableExceptionGroup(
-            "Unhandled non-retryable errors in a RecordBatch consumer TaskGroup", retryable + non_retryable
-        )
+    await logger.adebug("Finished consuming record batches")
 
     await raise_on_task_failure(producer_task)
     await logger.adebug("Successfully consumed all record batches")
diff --git a/posthog/temporal/batch_exports/temporary_file.py b/posthog/temporal/batch_exports/temporary_file.py
index c6a30ebc93a1b..afe91d42412a3 100644
--- a/posthog/temporal/batch_exports/temporary_file.py
+++ b/posthog/temporal/batch_exports/temporary_file.py
@@ -350,27 +350,33 @@ async def open_temporary_file(self, current_flush_counter: int = 0):
         self.reset_writer_tracking()
         self.flush_counter = current_flush_counter
 
-        with BatchExportTemporaryFile(**self.file_kwargs) as temp_file:
+        with self.create_temporary_file() as temp_file:
             self._batch_export_file = temp_file
 
             try:
-                yield
+                yield self
 
             except Exception as temp_err:
                 self.error = temp_err
                 raise
 
             finally:
-                self.track_bytes_written(temp_file)
+                await self.close_temporary_file()
 
-                if self.bytes_since_last_flush > 0:
-                    # `bytes_since_last_flush` should be 0 unless:
-                    # 1. The last batch wasn't flushed as it didn't reach `max_bytes`.
-                    # 2. The last batch was flushed but there was another write after the last call to
-                    #    `write_record_batch`. For example, footer bytes.
-                    await self.flush(is_last=True)
+    async def close_temporary_file(self):
+        self.track_bytes_written(self.batch_export_file)
+
+        if self.bytes_since_last_flush > 0:
+            # `bytes_since_last_flush` should be 0 unless:
+            # 1. The last batch wasn't flushed as it didn't reach `max_bytes`.
+            # 2. The last batch was flushed but there was another write after the last call to
+            #    `write_record_batch`. For example, footer bytes.
+            await self.flush(is_last=True)
 
-                self._batch_export_file = None
+        self._batch_export_file = None
+
+    def create_temporary_file(self) -> BatchExportTemporaryFile:
+        return BatchExportTemporaryFile(**self.file_kwargs)
 
     @property
     def batch_export_file(self):
@@ -662,6 +668,7 @@ def __init__(
         flush_callable: FlushCallable,
         schema: pa.Schema,
         compression: str | None = "snappy",
+        compression_level: int | None = None,
     ):
         super().__init__(
             max_bytes=max_bytes,
@@ -670,6 +677,7 @@ def __init__(
         )
         self.schema = schema
         self.compression = compression
+        self.compression_level = compression_level
 
         self._parquet_writer: pq.ParquetWriter | None = None
 
@@ -680,19 +688,17 @@ def parquet_writer(self) -> pq.ParquetWriter:
                 self.batch_export_file,
                 schema=self.schema,
                 compression="none" if self.compression is None else self.compression,
+                compression_level=self.compression_level,
             )
         return self._parquet_writer
 
-    @contextlib.asynccontextmanager
-    async def open_temporary_file(self, current_flush_counter: int = 0):
+    async def close_temporary_file(self):
         """Ensure underlying Parquet writer is closed before flushing and closing temporary file."""
-        async with super().open_temporary_file(current_flush_counter):
-            try:
-                yield
-            finally:
-                if self._parquet_writer is not None:
-                    self._parquet_writer.writer.close()
-                    self._parquet_writer = None
+        if self._parquet_writer is not None:
+            self._parquet_writer.writer.close()
+            self._parquet_writer = None
+
+        await super().close_temporary_file()
 
     def _write_record_batch(self, record_batch: pa.RecordBatch) -> None:
         """Write records to a temporary file as Parquet."""
diff --git a/posthog/temporal/common/clickhouse.py b/posthog/temporal/common/clickhouse.py
index 0cd0d909f21c9..f9c9516da907d 100644
--- a/posthog/temporal/common/clickhouse.py
+++ b/posthog/temporal/common/clickhouse.py
@@ -6,11 +6,11 @@
 import ssl
 import typing
 import uuid
-import structlog
 
 import aiohttp
 import pyarrow as pa
 import requests
+import structlog
 from django.conf import settings
 
 import posthog.temporal.common.asyncpa as asyncpa
@@ -511,6 +511,7 @@ async def get_client(
         max_memory_usage=settings.CLICKHOUSE_MAX_MEMORY_USAGE,
         max_block_size=max_block_size,
         output_format_arrow_string_as_string="true",
+        http_send_timeout=0,
         **kwargs,
     ) as client:
         yield client
diff --git a/posthog/temporal/data_imports/pipelines/bigquery/__init__.py b/posthog/temporal/data_imports/pipelines/bigquery/__init__.py
index 5d68f758a16bc..1519bf9e2abdd 100644
--- a/posthog/temporal/data_imports/pipelines/bigquery/__init__.py
+++ b/posthog/temporal/data_imports/pipelines/bigquery/__init__.py
@@ -1,8 +1,11 @@
 from collections import defaultdict
 import contextlib
+from typing import Optional
 from google.oauth2 import service_account
 from google.cloud import bigquery
+from posthog.temporal.common.logger import FilteringBoundLogger
 from posthog.warehouse.types import IncrementalFieldType
+from sentry_sdk.api import capture_exception
 
 # Actual data ingestion happens via the `sql_database` source. This is more for BigQuery utils
 
@@ -38,6 +41,28 @@ def delete_table(
         bq.delete_table(table_id, not_found_ok=True)
 
 
+def delete_all_temp_destination_tables(
+    dataset_id: str,
+    table_prefix: str,
+    project_id: str,
+    private_key: str,
+    private_key_id: str,
+    client_email: str,
+    token_uri: str,
+    logger: Optional[FilteringBoundLogger],
+) -> None:
+    with bigquery_client(project_id, private_key, private_key_id, client_email, token_uri) as bq:
+        try:
+            tables = bq.list_tables(bq.dataset(dataset_id))
+            for table in tables:
+                if table.table_id.startswith(table_prefix):
+                    bq.delete_table(table.reference)
+                    if logger:
+                        logger.debug(f"Deleted bigquery table {table.table_id}")
+        except Exception as e:
+            capture_exception(e)
+
+
 def get_schemas(
     dataset_id: str, project_id: str, private_key: str, private_key_id: str, client_email: str, token_uri: str
 ) -> dict[str, list[tuple[str, str]]]:
@@ -92,7 +117,8 @@ def validate_credentials(dataset_id: str, key_file: dict[str, str]) -> bool:
 
     with bigquery_client(project_id, private_key, private_key_id, client_email, token_uri) as bq:
         try:
-            bq.get_dataset(bq.dataset(dataset_id), retry=bigquery.DEFAULT_RETRY.with_timeout(5))
+            bq.list_tables(bq.dataset(dataset_id), retry=bigquery.DEFAULT_RETRY.with_timeout(5))
             return True
-        except:
+        except Exception as e:
+            capture_exception(e)
             return False
diff --git a/posthog/temporal/data_imports/pipelines/pipeline_sync.py b/posthog/temporal/data_imports/pipelines/pipeline_sync.py
index 4c1bf5b8b6709..8d2cbd6cac2ee 100644
--- a/posthog/temporal/data_imports/pipelines/pipeline_sync.py
+++ b/posthog/temporal/data_imports/pipelines/pipeline_sync.py
@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from datetime import datetime, date
 from typing import Any, Literal, Optional
 from collections.abc import Iterator, Sequence
 import uuid
@@ -6,8 +7,16 @@
 import dlt
 from django.conf import settings
 from django.db.models import Prefetch
+import dlt.common
+import dlt.common.libs
+import dlt.common.libs.pyarrow
+import dlt.extract
+import dlt.extract.incremental
+import dlt.extract.incremental.transform
 from dlt.pipeline.exceptions import PipelineStepFailed
 from deltalake import DeltaTable
+import pendulum
+import pyarrow
 
 from posthog.settings.base_variables import TEST
 from structlog.typing import FilteringBoundLogger
@@ -45,6 +54,21 @@
 from posthog.temporal.data_imports.util import prepare_s3_files_for_querying
 
 
+def _from_arrow_scalar(arrow_value: pyarrow.Scalar) -> Any:
+    """Converts arrow scalar into Python type. Currently adds "UTC" to naive date times and converts all others to UTC"""
+    row_value = arrow_value.as_py()
+
+    if isinstance(row_value, date) and not isinstance(row_value, datetime):
+        return row_value
+    elif isinstance(row_value, datetime):
+        row_value = pendulum.instance(row_value).in_tz("UTC")
+    return row_value
+
+
+dlt.common.libs.pyarrow.from_arrow_scalar = _from_arrow_scalar
+dlt.extract.incremental.transform.from_arrow_scalar = _from_arrow_scalar
+
+
 @dataclass
 class PipelineInputs:
     source_id: uuid.UUID
@@ -372,6 +396,10 @@ def _run(self) -> dict[str, int]:
             job_id=self.inputs.run_id, schema_id=str(self.inputs.schema_id), team_id=self.inputs.team_id
         )
 
+        if self._incremental:
+            self.logger.debug("Saving last incremental value...")
+            save_last_incremental_value(str(self.inputs.schema_id), str(self.inputs.team_id), self.source, self.logger)
+
         # Cleanup: delete local state from the file system
         pipeline.drop()
 
@@ -398,6 +426,28 @@ def update_last_synced_at_sync(job_id: str, schema_id: str, team_id: int) -> Non
     schema.save()
 
 
+def save_last_incremental_value(schema_id: str, team_id: str, source: DltSource, logger: FilteringBoundLogger) -> None:
+    schema = ExternalDataSchema.objects.exclude(deleted=True).get(id=schema_id, team_id=team_id)
+
+    incremental_field = schema.sync_type_config.get("incremental_field")
+    resource = next(iter(source.resources.values()))
+
+    incremental: dict | None = resource.state.get("incremental")
+
+    if incremental is None:
+        return
+
+    incremental_object: dict | None = incremental.get(incremental_field)
+    if incremental_object is None:
+        return
+
+    last_value = incremental_object.get("last_value")
+
+    logger.debug(f"Updating incremental_field_last_value with {last_value}")
+
+    schema.update_incremental_field_last_value(last_value)
+
+
 def validate_schema_and_update_table_sync(
     run_id: str,
     team_id: int,
diff --git a/posthog/temporal/data_imports/pipelines/sql_database/__init__.py b/posthog/temporal/data_imports/pipelines/sql_database/__init__.py
index fbf6a0ee01683..04aa7c9678c0b 100644
--- a/posthog/temporal/data_imports/pipelines/sql_database/__init__.py
+++ b/posthog/temporal/data_imports/pipelines/sql_database/__init__.py
@@ -21,6 +21,9 @@
 from posthog.warehouse.models.external_data_source import ExternalDataSource
 from sqlalchemy.sql import text
 
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import serialization
+
 from .helpers import (
     table_rows,
     engine_from_credentials,
@@ -109,8 +112,11 @@ def sql_source_for_type(
 
 def snowflake_source(
     account_id: str,
-    user: str,
-    password: str,
+    user: Optional[str],
+    password: Optional[str],
+    passphrase: Optional[str],
+    private_key: Optional[str],
+    auth_type: str,
     database: str,
     warehouse: str,
     schema: str,
@@ -119,13 +125,6 @@ def snowflake_source(
     incremental_field: Optional[str] = None,
     incremental_field_type: Optional[IncrementalFieldType] = None,
 ) -> DltSource:
-    account_id = quote(account_id)
-    user = quote(user)
-    password = quote(password)
-    database = quote(database)
-    warehouse = quote(warehouse)
-    role = quote(role) if role else None
-
     if incremental_field is not None and incremental_field_type is not None:
         incremental: dlt.sources.incremental | None = dlt.sources.incremental(
             cursor_path=incremental_field, initial_value=incremental_type_to_initial_value(incremental_field_type)
@@ -133,9 +132,46 @@ def snowflake_source(
     else:
         incremental = None
 
-    credentials = ConnectionStringCredentials(
-        f"snowflake://{user}:{password}@{account_id}/{database}/{schema}?warehouse={warehouse}{f'&role={role}' if role else ''}"
-    )
+    if auth_type == "password" and user is not None and password is not None:
+        account_id = quote(account_id)
+        user = quote(user)
+        password = quote(password)
+        database = quote(database)
+        warehouse = quote(warehouse)
+        role = quote(role) if role else None
+
+        credentials = create_engine(
+            f"snowflake://{user}:{password}@{account_id}/{database}/{schema}?warehouse={warehouse}{f'&role={role}' if role else ''}"
+        )
+    else:
+        assert private_key is not None
+        assert user is not None
+
+        account_id = quote(account_id)
+        user = quote(user)
+        database = quote(database)
+        warehouse = quote(warehouse)
+        role = quote(role) if role else None
+
+        p_key = serialization.load_pem_private_key(
+            private_key.encode("utf-8"),
+            password=passphrase.encode() if passphrase is not None else None,
+            backend=default_backend(),
+        )
+
+        pkb = p_key.private_bytes(
+            encoding=serialization.Encoding.DER,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+
+        credentials = create_engine(
+            f"snowflake://{user}@{account_id}/{database}/{schema}?warehouse={warehouse}{f'&role={role}' if role else ''}",
+            connect_args={
+                "private_key": pkb,
+            },
+        )
+
     db_source = sql_database(credentials, schema=schema, table_names=table_names, incremental=incremental)
 
     return db_source
diff --git a/posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py b/posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py
index cfd5f4cb822c0..bcab4c3e19282 100644
--- a/posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py
+++ b/posthog/temporal/data_imports/pipelines/sql_database_v2/__init__.py
@@ -20,6 +20,9 @@
 from posthog.warehouse.models import ExternalDataSource
 from posthog.warehouse.types import IncrementalFieldType
 
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import serialization
+
 from .helpers import (
     SelectAny,
     table_rows,
@@ -125,8 +128,11 @@ def sql_source_for_type(
 
 def snowflake_source(
     account_id: str,
-    user: str,
-    password: str,
+    user: Optional[str],
+    password: Optional[str],
+    passphrase: Optional[str],
+    private_key: Optional[str],
+    auth_type: str,
     database: str,
     warehouse: str,
     schema: str,
@@ -135,13 +141,6 @@ def snowflake_source(
     incremental_field: Optional[str] = None,
     incremental_field_type: Optional[IncrementalFieldType] = None,
 ) -> DltSource:
-    account_id = quote(account_id)
-    user = quote(user)
-    password = quote(password)
-    database = quote(database)
-    warehouse = quote(warehouse)
-    role = quote(role) if role else None
-
     if incremental_field is not None and incremental_field_type is not None:
         incremental: dlt.sources.incremental | None = dlt.sources.incremental(
             cursor_path=incremental_field, initial_value=incremental_type_to_initial_value(incremental_field_type)
@@ -149,9 +148,46 @@ def snowflake_source(
     else:
         incremental = None
 
-    credentials = ConnectionStringCredentials(
-        f"snowflake://{user}:{password}@{account_id}/{database}/{schema}?warehouse={warehouse}{f'&role={role}' if role else ''}"
-    )
+    if auth_type == "password" and user is not None and password is not None:
+        account_id = quote(account_id)
+        user = quote(user)
+        password = quote(password)
+        database = quote(database)
+        warehouse = quote(warehouse)
+        role = quote(role) if role else None
+
+        credentials = create_engine(
+            f"snowflake://{user}:{password}@{account_id}/{database}/{schema}?warehouse={warehouse}{f'&role={role}' if role else ''}"
+        )
+    else:
+        assert private_key is not None
+        assert user is not None
+
+        account_id = quote(account_id)
+        user = quote(user)
+        database = quote(database)
+        warehouse = quote(warehouse)
+        role = quote(role) if role else None
+
+        p_key = serialization.load_pem_private_key(
+            private_key.encode("utf-8"),
+            password=passphrase.encode() if passphrase is not None else None,
+            backend=default_backend(),
+        )
+
+        pkb = p_key.private_bytes(
+            encoding=serialization.Encoding.DER,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+
+        credentials = create_engine(
+            f"snowflake://{user}@{account_id}/{database}/{schema}?warehouse={warehouse}{f'&role={role}' if role else ''}",
+            connect_args={
+                "private_key": pkb,
+            },
+        )
+
     db_source = sql_database(credentials, schema=schema, table_names=table_names, incremental=incremental)
 
     return db_source
diff --git a/posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py b/posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py
index cc744eed0c9f6..6f6e883b3dc0d 100644
--- a/posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py
+++ b/posthog/temporal/data_imports/pipelines/sql_database_v2/schema_types.py
@@ -123,11 +123,16 @@ def sqla_col_to_column_schema(
         col["data_type"] = "date"
     elif isinstance(sql_t, sqltypes.Time):
         col["data_type"] = "time"
-    elif isinstance(sql_t, sqltypes.JSON) or isinstance(sql_t, BigQueryJSON) or isinstance(sql_t, BigQueryStruct):
+    elif (
+        isinstance(sql_t, sqltypes.JSON)
+        or isinstance(sql_t, BigQueryJSON)
+        or isinstance(sql_t, BigQueryStruct)
+        or isinstance(sql_t, ARRAY)
+    ):
         col["data_type"] = "json"
     elif isinstance(sql_t, sqltypes.Boolean):
         col["data_type"] = "bool"
-    elif isinstance(sql_t, sqltypes.Interval) or isinstance(sql_t, INTERVAL) or isinstance(sql_t, ARRAY):
+    elif isinstance(sql_t, sqltypes.Interval) or isinstance(sql_t, INTERVAL):
         # No support for interval columns yet - we filter out binary columns, so reusing the DLT type for interval columns to be removed
         col["data_type"] = "interval"  # type: ignore
     else:
diff --git a/posthog/temporal/data_imports/pipelines/test/test_pipeline_sync.py b/posthog/temporal/data_imports/pipelines/test/test_pipeline_sync.py
index 601c157acc20a..fcd84903b7249 100644
--- a/posthog/temporal/data_imports/pipelines/test/test_pipeline_sync.py
+++ b/posthog/temporal/data_imports/pipelines/test/test_pipeline_sync.py
@@ -134,6 +134,7 @@ def mock_create_pipeline(local_self: Any):
             ) as mock_validate_schema_and_update_table,
             patch("posthog.temporal.data_imports.pipelines.pipeline_sync.get_delta_tables"),
             patch("posthog.temporal.data_imports.pipelines.pipeline_sync.update_last_synced_at_sync"),
+            patch("posthog.temporal.data_imports.pipelines.pipeline_sync.save_last_incremental_value"),
             override_settings(
                 BUCKET_URL=f"s3://{BUCKET_NAME}",
                 AIRBYTE_BUCKET_KEY=settings.OBJECT_STORAGE_ACCESS_KEY_ID,
diff --git a/posthog/temporal/data_imports/workflow_activities/import_data_sync.py b/posthog/temporal/data_imports/workflow_activities/import_data_sync.py
index 091828d34ba52..81a4a943d2c4c 100644
--- a/posthog/temporal/data_imports/workflow_activities/import_data_sync.py
+++ b/posthog/temporal/data_imports/workflow_activities/import_data_sync.py
@@ -10,7 +10,7 @@
 
 from posthog.models.integration import Integration
 from posthog.temporal.common.heartbeat_sync import HeartbeaterSync
-from posthog.temporal.data_imports.pipelines.bigquery import delete_table
+from posthog.temporal.data_imports.pipelines.bigquery import delete_all_temp_destination_tables, delete_table
 
 from posthog.temporal.data_imports.pipelines.pipeline_sync import DataImportPipelineSync, PipelineInputs
 from posthog.temporal.data_imports.util import is_posthog_team
@@ -228,17 +228,24 @@ def import_data_activity_sync(inputs: ImportDataActivityInputs):
                 )
 
             account_id = model.pipeline.job_inputs.get("account_id")
-            user = model.pipeline.job_inputs.get("user")
-            password = model.pipeline.job_inputs.get("password")
             database = model.pipeline.job_inputs.get("database")
             warehouse = model.pipeline.job_inputs.get("warehouse")
             sf_schema = model.pipeline.job_inputs.get("schema")
             role = model.pipeline.job_inputs.get("role")
 
+            auth_type = model.pipeline.job_inputs.get("auth_type", "password")
+            auth_type_username = model.pipeline.job_inputs.get("user")
+            auth_type_password = model.pipeline.job_inputs.get("password")
+            auth_type_passphrase = model.pipeline.job_inputs.get("passphrase")
+            auth_type_private_key = model.pipeline.job_inputs.get("private_key")
+
             source = snowflake_source(
                 account_id=account_id,
-                user=user,
-                password=password,
+                auth_type=auth_type,
+                user=auth_type_username,
+                password=auth_type_password,
+                private_key=auth_type_private_key,
+                passphrase=auth_type_passphrase,
                 database=database,
                 schema=sf_schema,
                 warehouse=warehouse,
@@ -360,8 +367,20 @@ def import_data_activity_sync(inputs: ImportDataActivityInputs):
                 model.pipeline.job_inputs.get("using_temporary_dataset", False) and temporary_dataset_id is not None
             )
 
+            destination_table_prefix = "__posthog_import_"
             destination_table_dataset_id = temporary_dataset_id if using_temporary_dataset else dataset_id
-            destination_table = f"{project_id}.{destination_table_dataset_id}.__posthog_import_{inputs.run_id}_{str(datetime.now().timestamp()).replace('.', '')}"
+            destination_table = f"{project_id}.{destination_table_dataset_id}.{destination_table_prefix}{inputs.run_id}_{str(datetime.now().timestamp()).replace('.', '')}"
+
+            delete_all_temp_destination_tables(
+                dataset_id=dataset_id,
+                table_prefix=destination_table_prefix,
+                project_id=project_id,
+                private_key=private_key,
+                private_key_id=private_key_id,
+                client_email=client_email,
+                token_uri=token_uri,
+                logger=logger,
+            )
 
             try:
                 source = bigquery_source(
diff --git a/posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py b/posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py
index 67f8c820e2837..b63d7ea869e16 100644
--- a/posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py
+++ b/posthog/temporal/data_imports/workflow_activities/sync_new_schemas.py
@@ -86,14 +86,29 @@ def sync_new_schemas_activity(inputs: SyncNewSchemasActivityInputs) -> None:
             return
 
         account_id = source.job_inputs.get("account_id")
-        user = source.job_inputs.get("user")
-        password = source.job_inputs.get("password")
         database = source.job_inputs.get("database")
         warehouse = source.job_inputs.get("warehouse")
         sf_schema = source.job_inputs.get("schema")
         role = source.job_inputs.get("role")
 
-        sql_schemas = get_snowflake_schemas(account_id, database, warehouse, user, password, sf_schema, role)
+        auth_type = source.job_inputs.get("auth_type", "password")
+        auth_type_username = source.job_inputs.get("user")
+        auth_type_password = source.job_inputs.get("password")
+        auth_type_passphrase = source.job_inputs.get("passphrase")
+        auth_type_private_key = source.job_inputs.get("private_key")
+
+        sql_schemas = get_snowflake_schemas(
+            account_id=account_id,
+            database=database,
+            warehouse=warehouse,
+            user=auth_type_username,
+            password=auth_type_password,
+            schema=sf_schema,
+            role=role,
+            auth_type=auth_type,
+            passphrase=auth_type_passphrase,
+            private_key=auth_type_private_key,
+        )
 
         schemas_to_sync = list(sql_schemas.keys())
     else:
diff --git a/posthog/temporal/tests/batch_exports/conftest.py b/posthog/temporal/tests/batch_exports/conftest.py
index 67c321205a14f..7044d8fe96868 100644
--- a/posthog/temporal/tests/batch_exports/conftest.py
+++ b/posthog/temporal/tests/batch_exports/conftest.py
@@ -152,8 +152,8 @@ async def create_clickhouse_tables_and_views(clickhouse_client, django_db_setup)
     from posthog.batch_exports.sql import (
         CREATE_EVENTS_BATCH_EXPORT_VIEW,
         CREATE_EVENTS_BATCH_EXPORT_VIEW_BACKFILL,
-        CREATE_EVENTS_BATCH_EXPORT_VIEW_UNBOUNDED,
         CREATE_EVENTS_BATCH_EXPORT_VIEW_RECENT,
+        CREATE_EVENTS_BATCH_EXPORT_VIEW_UNBOUNDED,
         CREATE_PERSONS_BATCH_EXPORT_VIEW,
         CREATE_PERSONS_BATCH_EXPORT_VIEW_BACKFILL,
     )
@@ -211,8 +211,12 @@ def data_interval_start(request, data_interval_end, interval):
 
 
 @pytest.fixture
-def data_interval_end(interval):
+def data_interval_end(request, interval):
     """Set a test data interval end."""
+    try:
+        return request.param
+    except AttributeError:
+        pass
     return dt.datetime(2023, 4, 25, 15, 0, 0, tzinfo=dt.UTC)
 
 
diff --git a/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py b/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py
index b4ec82c7eacfc..0fe8f01cd2366 100644
--- a/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py
+++ b/posthog/temporal/tests/batch_exports/test_bigquery_batch_export_workflow.py
@@ -4,12 +4,14 @@
 import operator
 import os
 import typing
+import unittest.mock
 import uuid
 import warnings
 
 import pyarrow as pa
 import pytest
 import pytest_asyncio
+from django.test import override_settings
 from freezegun.api import freeze_time
 from google.cloud import bigquery
 from temporalio import activity
@@ -361,11 +363,86 @@ async def test_insert_into_bigquery_activity_inserts_data_into_bigquery_table(
         **bigquery_config,
     )
 
-    with freeze_time(TEST_TIME) as frozen_time:
+    with freeze_time(TEST_TIME) as frozen_time, override_settings(BATCH_EXPORT_BIGQUERY_UPLOAD_CHUNK_SIZE_BYTES=1):
+        await activity_environment.run(insert_into_bigquery_activity, insert_inputs)
+
+        ingested_timestamp = frozen_time().replace(tzinfo=dt.UTC)
+
+        await assert_clickhouse_records_in_bigquery(
+            bigquery_client=bigquery_client,
+            clickhouse_client=clickhouse_client,
+            table_id=f"test_insert_activity_table_{ateam.pk}",
+            dataset_id=bigquery_dataset.dataset_id,
+            team_id=ateam.pk,
+            date_ranges=[(data_interval_start, data_interval_end)],
+            exclude_events=exclude_events,
+            include_events=None,
+            batch_export_model=model,
+            use_json_type=use_json_type,
+            min_ingested_timestamp=ingested_timestamp,
+            sort_key="person_id"
+            if batch_export_model is not None and batch_export_model.name == "persons"
+            else "event",
+        )
+
+
+@pytest.mark.parametrize("use_json_type", [True], indirect=True)
+@pytest.mark.parametrize("model", TEST_MODELS)
+async def test_insert_into_bigquery_activity_inserts_data_into_bigquery_table_without_query_permissions(
+    clickhouse_client,
+    activity_environment,
+    bigquery_client,
+    bigquery_config,
+    exclude_events,
+    bigquery_dataset,
+    use_json_type,
+    model: BatchExportModel | BatchExportSchema | None,
+    generate_test_data,
+    data_interval_start,
+    data_interval_end,
+    ateam,
+):
+    """Test that the `insert_into_bigquery_activity` function inserts data into a BigQuery table.
+
+    For this test we mock the `acheck_for_query_permissions_on_table` method to assert the
+    behavior of the activity function when lacking query permissions in BigQuery.
+    """
+    if isinstance(model, BatchExportModel) and model.name == "persons":
+        pytest.skip("Unnecessary test case as person batch export requires query permissions")
+
+    batch_export_schema: BatchExportSchema | None = None
+    batch_export_model: BatchExportModel | None = None
+    if isinstance(model, BatchExportModel):
+        batch_export_model = model
+    elif model is not None:
+        batch_export_schema = model
+
+    insert_inputs = BigQueryInsertInputs(
+        team_id=ateam.pk,
+        table_id=f"test_insert_activity_table_{ateam.pk}",
+        dataset_id=bigquery_dataset.dataset_id,
+        data_interval_start=data_interval_start.isoformat(),
+        data_interval_end=data_interval_end.isoformat(),
+        exclude_events=exclude_events,
+        use_json_type=use_json_type,
+        batch_export_schema=batch_export_schema,
+        batch_export_model=batch_export_model,
+        **bigquery_config,
+    )
+
+    with (
+        freeze_time(TEST_TIME) as frozen_time,
+        override_settings(BATCH_EXPORT_BIGQUERY_UPLOAD_CHUNK_SIZE_BYTES=1),
+        unittest.mock.patch(
+            "posthog.temporal.batch_exports.bigquery_batch_export.BigQueryClient.acheck_for_query_permissions_on_table",
+            return_value=False,
+        ) as mocked_check,
+    ):
         await activity_environment.run(insert_into_bigquery_activity, insert_inputs)
 
         ingested_timestamp = frozen_time().replace(tzinfo=dt.UTC)
 
+        mocked_check.assert_called_once()
         await assert_clickhouse_records_in_bigquery(
             bigquery_client=bigquery_client,
             clickhouse_client=clickhouse_client,
diff --git a/posthog/temporal/tests/batch_exports/test_monitoring.py b/posthog/temporal/tests/batch_exports/test_monitoring.py
new file mode 100644
index 0000000000000..cab50c25d3177
--- /dev/null
+++ b/posthog/temporal/tests/batch_exports/test_monitoring.py
@@ -0,0 +1,201 @@
+import datetime as dt
+import uuid
+
+import pytest
+import pytest_asyncio
+from temporalio.common import RetryPolicy
+from temporalio.testing import WorkflowEnvironment
+from temporalio.worker import UnsandboxedWorkflowRunner, Worker
+
+from posthog import constants
+from posthog.batch_exports.models import BatchExportRun
+from posthog.temporal.batch_exports.monitoring import (
+    BatchExportMonitoringInputs,
+    BatchExportMonitoringWorkflow,
+    get_batch_export,
+    get_event_counts,
+    update_batch_export_runs,
+)
+from posthog.temporal.tests.utils.models import (
+    acreate_batch_export,
+    adelete_batch_export,
+    afetch_batch_export_runs,
+)
+
+pytestmark = [pytest.mark.asyncio, pytest.mark.django_db]
+
+GENERATE_TEST_DATA_END = dt.datetime.now(tz=dt.UTC).replace(
+    minute=0, second=0, microsecond=0, tzinfo=dt.UTC
+) - dt.timedelta(hours=1)
+GENERATE_TEST_DATA_START = GENERATE_TEST_DATA_END - dt.timedelta(hours=1)
+
+
+@pytest_asyncio.fixture
+async def batch_export(ateam, temporal_client):
+    """Provide a batch export for tests, not intended to be used."""
+    destination_data = {
+        "type": "S3",
+        "config": {
+            "bucket_name": "a-bucket",
+            "region": "us-east-1",
+            "prefix": "a-key",
+            "aws_access_key_id": "object_storage_root_user",
+            "aws_secret_access_key": "object_storage_root_password",
+        },
+    }
+
+    batch_export_data = {
+        "name": "my-production-s3-bucket-destination",
+        "destination": destination_data,
+        "interval": "every 5 minutes",
+    }
+
+    batch_export = await acreate_batch_export(
+        team_id=ateam.pk,
+        name=batch_export_data["name"],  # type: ignore
+        destination_data=batch_export_data["destination"],  # type: ignore
+        interval=batch_export_data["interval"],  # type: ignore
+    )
+
+    yield batch_export
+
+    await adelete_batch_export(batch_export, temporal_client)
+
+
+@pytest_asyncio.fixture
+async def generate_batch_export_runs(
+    generate_test_data,
+    data_interval_start: dt.datetime,
+    data_interval_end: dt.datetime,
+    interval: str,
+    batch_export,
+):
+    # to keep things simple for now, we assume 5 min interval
+    if interval != "every 5 minutes":
+        raise NotImplementedError("Only 5 minute intervals are supported for now. Please update the test.")
+
+    events_created, _ = generate_test_data
+
+    batch_export_runs: list[BatchExportRun] = []
+    interval_start = data_interval_start
+    interval_end = interval_start + dt.timedelta(minutes=5)
+    while interval_end <= data_interval_end:
+        run = BatchExportRun(
+            batch_export_id=batch_export.id,
+            data_interval_start=interval_start,
+            data_interval_end=interval_end,
+            status="completed",
+            records_completed=len(
+                [
+                    e
+                    for e in events_created
+                    if interval_start
+                    <= dt.datetime.fromisoformat(e["inserted_at"]).replace(tzinfo=dt.UTC)
+                    < interval_end
+                ]
+            ),
+        )
+        await run.asave()
+        batch_export_runs.append(run)
+        interval_start = interval_end
+        interval_end += dt.timedelta(minutes=5)
+
+    yield
+
+    for run in batch_export_runs:
+        await run.adelete()
+
+
+async def test_monitoring_workflow_when_no_event_data(batch_export):
+    workflow_id = str(uuid.uuid4())
+    inputs = BatchExportMonitoringInputs(batch_export_id=batch_export.id)
+    async with await WorkflowEnvironment.start_time_skipping() as activity_environment:
+        async with Worker(
+            activity_environment.client,
+            # TODO - not sure if this is the right task queue
+            task_queue=constants.BATCH_EXPORTS_TASK_QUEUE,
+            workflows=[BatchExportMonitoringWorkflow],
+            activities=[
+                get_batch_export,
+                get_event_counts,
+                update_batch_export_runs,
+            ],
+            workflow_runner=UnsandboxedWorkflowRunner(),
+        ):
+            batch_export_runs_updated = await activity_environment.client.execute_workflow(
+                BatchExportMonitoringWorkflow.run,
+                inputs,
+                id=workflow_id,
+                task_queue=constants.BATCH_EXPORTS_TASK_QUEUE,
+                retry_policy=RetryPolicy(maximum_attempts=1),
+                execution_timeout=dt.timedelta(seconds=30),
+            )
+            assert batch_export_runs_updated == 0
+
+
+@pytest.mark.parametrize(
+    "data_interval_start",
+    [GENERATE_TEST_DATA_START],
+    indirect=True,
+)
+@pytest.mark.parametrize(
+    "data_interval_end",
+    [GENERATE_TEST_DATA_END],
+    indirect=True,
+)
+@pytest.mark.parametrize(
+    "interval",
+    ["every 5 minutes"],
+    indirect=True,
+)
+async def test_monitoring_workflow(
+    batch_export,
+    generate_test_data,
+    data_interval_start,
+    data_interval_end,
+    interval,
+    generate_batch_export_runs,
+):
+    """Test the monitoring workflow with a batch export that has data.
+
+    We generate 2 hours of data between 13:00 and 15:00, and then run the
+    monitoring workflow at 15:30.  The monitoring workflow should check the data
+    between 14:00 and 15:00, and update the batch export runs.
+
+    We generate some dummy batch export runs based on the event data we
+    generated and assert that the expected records count matches the records
+    completed.
+    """
+    workflow_id = str(uuid.uuid4())
+    inputs = BatchExportMonitoringInputs(batch_export_id=batch_export.id)
+    async with await WorkflowEnvironment.start_time_skipping() as activity_environment:
+        async with Worker(
+            activity_environment.client,
+            # TODO - not sure if this is the right task queue
+            task_queue=constants.BATCH_EXPORTS_TASK_QUEUE,
+            workflows=[BatchExportMonitoringWorkflow],
+            activities=[
+                get_batch_export,
+                get_event_counts,
+                update_batch_export_runs,
+            ],
+            workflow_runner=UnsandboxedWorkflowRunner(),
+        ):
+            await activity_environment.client.execute_workflow(
+                BatchExportMonitoringWorkflow.run,
+                inputs,
+                id=workflow_id,
+                task_queue=constants.BATCH_EXPORTS_TASK_QUEUE,
+                retry_policy=RetryPolicy(maximum_attempts=1),
+                execution_timeout=dt.timedelta(seconds=30),
+            )
+
+    batch_export_runs = await afetch_batch_export_runs(batch_export_id=batch_export.id)
+
+    for run in batch_export_runs:
+        if run.records_completed == 0:
+            # TODO: in the actual monitoring activity it would be better to
+            # update the actual count to 0 rather than None
+            assert run.records_total_count is None
+        else:
+            assert run.records_completed == run.records_total_count
diff --git a/posthog/temporal/tests/batch_exports/test_s3_batch_export_workflow.py b/posthog/temporal/tests/batch_exports/test_s3_batch_export_workflow.py
index 979869c4b31d7..76a3c20599518 100644
--- a/posthog/temporal/tests/batch_exports/test_s3_batch_export_workflow.py
+++ b/posthog/temporal/tests/batch_exports/test_s3_batch_export_workflow.py
@@ -29,6 +29,7 @@
 from posthog.temporal.batch_exports.s3_batch_export import (
     FILE_FORMAT_EXTENSIONS,
     IntermittentUploadPartTimeoutError,
+    InvalidS3EndpointError,
     S3BatchExportInputs,
     S3BatchExportWorkflow,
     S3HeartbeatDetails,
@@ -40,9 +41,7 @@
 )
 from posthog.temporal.common.clickhouse import ClickHouseClient
 from posthog.temporal.tests.batch_exports.utils import mocked_start_batch_export_run
-from posthog.temporal.tests.utils.events import (
-    generate_test_events_in_clickhouse,
-)
+from posthog.temporal.tests.utils.events import generate_test_events_in_clickhouse
 from posthog.temporal.tests.utils.models import (
     acreate_batch_export,
     adelete_batch_export,
@@ -387,6 +386,102 @@ async def test_insert_into_s3_activity_puts_data_into_s3(
     )
 
 
+@pytest.mark.parametrize("compression", [None, "gzip"], indirect=True)
+@pytest.mark.parametrize("model", [BatchExportModel(name="events", schema=None)])
+@pytest.mark.parametrize("file_format", ["Parquet"])
+async def test_insert_into_s3_activity_puts_splitted_parquet_data_into_s3(
+    clickhouse_client,
+    bucket_name,
+    minio_client,
+    activity_environment,
+    compression,
+    exclude_events,
+    file_format,
+    data_interval_start,
+    data_interval_end,
+    model: BatchExportModel | BatchExportSchema | None,
+    ateam,
+):
+    """Test that the insert_into_s3_activity function exports uncorrupted parquet data.
+
+    More specifically, we are interested in what happens when there is the need to split
+    up a parquet file into multiple parts, so we generate a lot of data for this test.
+    """
+    prefix = str(uuid.uuid4())
+
+    events_1, _, _ = await generate_test_events_in_clickhouse(
+        client=clickhouse_client,
+        team_id=ateam.pk,
+        start_time=data_interval_start,
+        end_time=data_interval_end,
+        count=100000,
+        count_outside_range=0,
+        count_other_team=0,
+        duplicate=False,
+        properties={"$prop1": 123},
+    )
+
+    events_2, _, _ = await generate_test_events_in_clickhouse(
+        client=clickhouse_client,
+        team_id=ateam.pk,
+        start_time=data_interval_start,
+        end_time=data_interval_end,
+        count=100000,
+        count_outside_range=0,
+        count_other_team=0,
+        duplicate=False,
+        properties={"$prop1": 123},
+    )
+
+    events_to_export_created = events_1 + events_2
+
+    batch_export_schema: BatchExportSchema | None = None
+    batch_export_model: BatchExportModel | None = None
+    if isinstance(model, BatchExportModel):
+        batch_export_model = model
+    elif model is not None:
+        batch_export_schema = model
+
+    insert_inputs = S3InsertInputs(
+        bucket_name=bucket_name,
+        region="us-east-1",
+        prefix=prefix,
+        team_id=ateam.pk,
+        data_interval_start=data_interval_start.isoformat(),
+        data_interval_end=data_interval_end.isoformat(),
+        aws_access_key_id="object_storage_root_user",
+        aws_secret_access_key="object_storage_root_password",
+        endpoint_url=settings.OBJECT_STORAGE_ENDPOINT,
+        compression=compression,
+        exclude_events=exclude_events,
+        file_format=file_format,
+        batch_export_schema=batch_export_schema,
+        batch_export_model=batch_export_model,
+    )
+
+    with override_settings(
+        BATCH_EXPORT_S3_UPLOAD_CHUNK_SIZE_BYTES=5 * 1024**2
+    ):  # 5MB, the minimum for Multipart uploads
+        records_exported = await activity_environment.run(insert_into_s3_activity, insert_inputs)
+
+    assert records_exported == len(events_to_export_created)
+
+    # Takes a long time to re-read this data from ClickHouse, so we just make sure that:
+    # 1. The file exists in S3.
+    # 2. We can read it (so, it's a valid parquet).
+    # 3. It has the same length as the events we have created.
+    s3_data = await assert_file_in_s3(
+        s3_compatible_client=minio_client,
+        bucket_name=bucket_name,
+        key_prefix=prefix,
+        file_format=file_format,
+        compression=compression,
+        json_columns=("properties", "person_properties", "set", "set_once"),
+    )
+
+    assert len(s3_data) == len(events_to_export_created)
+
+
 @pytest.mark.parametrize("model", [model for model in TEST_S3_MODELS if model is not None])
 async def test_insert_into_s3_activity_puts_data_into_s3_using_async(
     clickhouse_client,
@@ -1480,6 +1575,23 @@ async def client(self, *args, **kwargs):
         await s3_upload.upload_part(io.BytesIO(b"1010"), rewind=False)  # type: ignore
 
 
+async def test_s3_multi_part_upload_raises_exception_if_invalid_endpoint(bucket_name, s3_key_prefix):
+    """Test a InvalidS3EndpointError is raised if the endpoint is invalid."""
+    s3_upload = S3MultiPartUpload(
+        bucket_name=bucket_name,
+        key=s3_key_prefix,
+        encryption=None,
+        kms_key_id=None,
+        region_name="us-east-1",
+        aws_access_key_id="object_storage_root_user",
+        aws_secret_access_key="object_storage_root_password",
+        endpoint_url="some-invalid-endpoint",
+    )
+
+    with pytest.raises(InvalidS3EndpointError):
+        await s3_upload.start()
+
+
 @pytest.mark.parametrize("model", [TEST_S3_MODELS[1], TEST_S3_MODELS[2], None])
 async def test_s3_export_workflow_with_request_timeouts(
     clickhouse_client,
@@ -1589,7 +1701,7 @@ def __init__(self, *args, **kwargs):
     assert run.records_completed is None
     assert (
         run.latest_error
-        == "RecordBatchConsumerRetryableExceptionGroup: At least one unhandled retryable errors in a RecordBatch consumer TaskGroup (1 sub-exception)"
+        == "IntermittentUploadPartTimeoutError: An intermittent `RequestTimeout` was raised while attempting to upload part 1"
     )
 
     run = runs[1]
diff --git a/posthog/test/__snapshots__/test_feature_flag.ambr b/posthog/test/__snapshots__/test_feature_flag.ambr
index fefcbbffd5d46..26e3b9acfa02a 100644
--- a/posthog/test/__snapshots__/test_feature_flag.ambr
+++ b/posthog/test/__snapshots__/test_feature_flag.ambr
@@ -216,7 +216,1148 @@
          AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.10
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.11
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.12
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.13
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.14
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.15
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.16
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.17
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.18
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.19
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
 # name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.2
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.20
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.21
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.22
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.23
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.24
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.25
+  '''
+  SELECT ((("posthog_person"."properties" -> 'Distinct Id') IN ('"307"'::jsonb)
+           OR ("posthog_person"."properties" -> 'Distinct Id') IN ('307'::jsonb))
+          AND "posthog_person"."properties" ? 'Distinct Id'
+          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.26
+  '''
+  SELECT (("posthog_person"."properties" -> 'Distinct Id') IN ('307'::jsonb)
+          AND "posthog_person"."properties" ? 'Distinct Id'
+          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.27
+  '''
+  SELECT (("posthog_person"."properties" -> 'Distinct Id') = '307'::jsonb
+          AND "posthog_person"."properties" ? 'Distinct Id'
+          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.28
+  '''
+  SELECT ((("posthog_person"."properties" -> 'Distinct Id') IN ('"307"'::jsonb)
+           OR ("posthog_person"."properties" -> 'Distinct Id') IN ('307'::jsonb))
+          AND "posthog_person"."properties" ? 'Distinct Id'
+          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.29
+  '''
+  SELECT (("posthog_person"."properties" -> 'Distinct Id') IN ('307'::jsonb)
+          AND "posthog_person"."properties" ? 'Distinct Id'
+          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.3
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.30
+  '''
+  SELECT (("posthog_person"."properties" -> 'Distinct Id') = '307'::jsonb
+          AND "posthog_person"."properties" ? 'Distinct Id'
+          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.4
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.5
+  '''
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.6
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.7
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.8
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.9
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -239,7 +1380,77 @@
          AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.3
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.1
   '''
   SELECT "posthog_featureflag"."id",
          "posthog_featureflag"."key",
@@ -262,44 +1473,106 @@
          AND "posthog_featureflag"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.4
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.10
   '''
-  SELECT ((("posthog_person"."properties" -> 'Distinct Id') IN ('"307"'::jsonb)
-           OR ("posthog_person"."properties" -> 'Distinct Id') IN ('307'::jsonb))
-          AND "posthog_person"."properties" ? 'Distinct Id'
-          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  SELECT (("posthog_person"."properties" ->> 'email')::text ~ '["neil@x.com"]'
+          AND "posthog_person"."properties" ? 'email'
+          AND NOT (("posthog_person"."properties" -> 'email') = 'null'::jsonb)) AS "flag_X_condition_0"
   FROM "posthog_person"
   INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
          AND "posthog_persondistinctid"."team_id" = 99999
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.5
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.11
   '''
-  SELECT (("posthog_person"."properties" -> 'Distinct Id') IN ('307'::jsonb)
-          AND "posthog_person"."properties" ? 'Distinct Id'
-          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
+  SELECT (("posthog_person"."properties" ->> 'email')::text ~ '["neil@x.com"]'
+          AND "posthog_person"."properties" ? 'email'
+          AND NOT (("posthog_person"."properties" -> 'email') = 'null'::jsonb)) AS "flag_X_condition_0"
   FROM "posthog_person"
   INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
          AND "posthog_persondistinctid"."team_id" = 99999
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_db_matches_independent_of_string_or_number_type.6
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.2
   '''
-  SELECT (("posthog_person"."properties" -> 'Distinct Id') = '307'::jsonb
-          AND "posthog_person"."properties" ? 'Distinct Id'
-          AND NOT (("posthog_person"."properties" -> 'Distinct Id') = 'null'::jsonb)) AS "flag_X_condition_0"
-  FROM "posthog_person"
-  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
-         AND "posthog_persondistinctid"."team_id" = 99999
-         AND "posthog_person"."team_id" = 99999)
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.3
+  '''
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.4
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -369,9 +1642,47 @@
   LIMIT 21
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.1
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.5
   '''
-  SELECT "posthog_featureflag"."id",
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.6
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
          "posthog_featureflag"."key",
          "posthog_featureflag"."name",
          "posthog_featureflag"."filters",
@@ -385,14 +1696,156 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.7
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.8
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.2
+# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.9
   '''
   SELECT (("posthog_person"."properties" ->> 'email')::text ~ '["neil@x.com"]'
           AND "posthog_person"."properties" ? 'email'
@@ -404,18 +1857,6 @@
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_invalid_regex_match_flag.3
-  '''
-  SELECT (("posthog_person"."properties" ->> 'email')::text ~ '["neil@x.com"]'
-          AND "posthog_person"."properties" ? 'email'
-          AND NOT (("posthog_person"."properties" -> 'email') = 'null'::jsonb)) AS "flag_X_condition_0"
-  FROM "posthog_person"
-  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = 'another_id'
-         AND "posthog_persondistinctid"."team_id" = 99999
-         AND "posthog_person"."team_id" = 99999)
-  '''
-# ---
 # name: TestFeatureFlagMatcher.test_multiple_flags
   '''
   SELECT "posthog_grouptypemapping"."id",
@@ -598,52 +2039,294 @@
          AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_numeric_operator_with_groups_and_person_flags.2
+# name: TestFeatureFlagMatcher.test_numeric_operator_with_groups_and_person_flags.2
+  '''
+  SELECT (((("posthog_group"."group_properties" -> 'number') > '"100"'::jsonb
+            AND JSONB_TYPEOF(("posthog_group"."group_properties" -> 'number')) = ('string'))
+           OR (("posthog_group"."group_properties" -> 'number') > '100.0'::jsonb
+               AND JSONB_TYPEOF(("posthog_group"."group_properties" -> 'number')) = ('number')))
+          AND "posthog_group"."group_properties" ? 'number'
+          AND NOT (("posthog_group"."group_properties" -> 'number') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_group"
+  WHERE ("posthog_group"."team_id" = 99999
+         AND "posthog_group"."group_key" = 'foo'
+         AND "posthog_group"."group_type_index" = 0)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_numeric_operator_with_groups_and_person_flags.3
+  '''
+  SELECT (("posthog_group"."group_properties" -> 'number') > '"100b2c"'::jsonb
+          AND "posthog_group"."group_properties" ? 'number'
+          AND NOT (("posthog_group"."group_properties" -> 'number') = 'null'::jsonb)) AS "flag_X_condition_0"
+  FROM "posthog_group"
+  WHERE ("posthog_group"."team_id" = 99999
+         AND "posthog_group"."group_key" = 'foo-project'
+         AND "posthog_group"."group_type_index" = 1)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_super_condition_matches_string
+  '''
+  SELECT ((("posthog_person"."properties" -> 'is_enabled') = 'true'::jsonb
+           OR ("posthog_person"."properties" -> 'is_enabled') = '"true"'::jsonb)
+          AND "posthog_person"."properties" ? 'is_enabled'
+          AND NOT (("posthog_person"."properties" -> 'is_enabled') = 'null'::jsonb)) AS "flag_X_super_condition", ("posthog_person"."properties" -> 'is_enabled') IS NOT NULL AS "flag_X_super_condition_is_set",
+                                                                                                                                                                                 (("posthog_person"."properties" -> 'email') = '"fake@posthog.com"'::jsonb
+                                                                                                                                                                                  AND "posthog_person"."properties" ? 'email'
+                                                                                                                                                                                  AND NOT (("posthog_person"."properties" -> 'email') = 'null'::jsonb)) AS "flag_X_condition_0",
+                                                                                                                                                                                 (("posthog_person"."properties" -> 'email') = '"test@posthog.com"'::jsonb
+                                                                                                                                                                                  AND "posthog_person"."properties" ? 'email'
+                                                                                                                                                                                  AND NOT (("posthog_person"."properties" -> 'email') = 'null'::jsonb)) AS "flag_X_condition_1",
+                                                                                                                                                                                 (true) AS "flag_X_condition_2"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = 'test_id'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases
+  '''
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.1
+  '''
+  SELECT "posthog_featureflag"."id",
+         "posthog_featureflag"."key",
+         "posthog_featureflag"."name",
+         "posthog_featureflag"."filters",
+         "posthog_featureflag"."rollout_percentage",
+         "posthog_featureflag"."team_id",
+         "posthog_featureflag"."created_by_id",
+         "posthog_featureflag"."created_at",
+         "posthog_featureflag"."deleted",
+         "posthog_featureflag"."active",
+         "posthog_featureflag"."rollback_conditions",
+         "posthog_featureflag"."performed_rollback",
+         "posthog_featureflag"."ensure_experience_continuity",
+         "posthog_featureflag"."usage_dashboard_id",
+         "posthog_featureflag"."has_enriched_analytics"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.10
+  '''
+  SELECT (((("posthog_person"."properties" -> 'number space') > '"100"'::jsonb
+            AND JSONB_TYPEOF(("posthog_person"."properties" -> 'number space')) = ('string'))
+           OR (("posthog_person"."properties" -> 'number space') > '100.0'::jsonb
+               AND JSONB_TYPEOF(("posthog_person"."properties" -> 'number space')) = ('number')))
+          AND "posthog_person"."properties" ? 'number space'
+          AND NOT (("posthog_person"."properties" -> 'number space') = 'null'::jsonb)
+          AND ((JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('string')
+                AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '"100"'::jsonb)
+               OR (JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('number')
+                   AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '100.0'::jsonb))
+          AND "posthog_person"."properties" ? ';''" SELECT 1; DROP TABLE posthog_featureflag;'
+          AND NOT (("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') = 'null'::jsonb)) AS "flag_X_condition_0",
+         (((JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('string')
+            AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '"100"'::jsonb)
+           OR (JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('number')
+               AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '100.0'::jsonb))
+          AND "posthog_person"."properties" ? ';''" SELECT 1; DROP TABLE posthog_featureflag;'
+          AND NOT (("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') = 'null'::jsonb)) AS "flag_X_condition_1",
+         (((("posthog_person"."properties" -> 'version!!!') > '"1.05"'::jsonb
+            AND JSONB_TYPEOF(("posthog_person"."properties" -> 'version!!!')) = ('string'))
+           OR (("posthog_person"."properties" -> 'version!!!') > '1.05'::jsonb
+               AND JSONB_TYPEOF(("posthog_person"."properties" -> 'version!!!')) = ('number')))
+          AND "posthog_person"."properties" ? 'version!!!'
+          AND NOT (("posthog_person"."properties" -> 'version!!!') = 'null'::jsonb)) AS "flag_X_condition_2",
+         ((("posthog_person"."properties" -> 'nested_prop --random #comment //test') = '"21"'::jsonb
+           OR ("posthog_person"."properties" -> 'nested_prop --random #comment //test') = '21'::jsonb)
+          AND "posthog_person"."properties" ? 'nested_prop --random #comment //test'
+          AND NOT (("posthog_person"."properties" -> 'nested_prop --random #comment //test') = 'null'::jsonb)) AS "flag_X_condition_3"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.11
   '''
-  SELECT (((("posthog_group"."group_properties" -> 'number') > '"100"'::jsonb
-            AND JSONB_TYPEOF(("posthog_group"."group_properties" -> 'number')) = ('string'))
-           OR (("posthog_group"."group_properties" -> 'number') > '100.0'::jsonb
-               AND JSONB_TYPEOF(("posthog_group"."group_properties" -> 'number')) = ('number')))
-          AND "posthog_group"."group_properties" ? 'number'
-          AND NOT (("posthog_group"."group_properties" -> 'number') = 'null'::jsonb)) AS "flag_X_condition_0"
-  FROM "posthog_group"
-  WHERE ("posthog_group"."team_id" = 99999
-         AND "posthog_group"."group_key" = 'foo'
-         AND "posthog_group"."group_type_index" = 0)
+  SELECT (((("posthog_person"."properties" -> 'number space') > '"100"'::jsonb
+            AND JSONB_TYPEOF(("posthog_person"."properties" -> 'number space')) = ('string'))
+           OR (("posthog_person"."properties" -> 'number space') > '100.0'::jsonb
+               AND JSONB_TYPEOF(("posthog_person"."properties" -> 'number space')) = ('number')))
+          AND "posthog_person"."properties" ? 'number space'
+          AND NOT (("posthog_person"."properties" -> 'number space') = 'null'::jsonb)
+          AND ((JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('string')
+                AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '"100"'::jsonb)
+               OR (JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('number')
+                   AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '100.0'::jsonb))
+          AND "posthog_person"."properties" ? ';''" SELECT 1; DROP TABLE posthog_featureflag;'
+          AND NOT (("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') = 'null'::jsonb)) AS "flag_X_condition_0",
+         (((JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('string')
+            AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '"100"'::jsonb)
+           OR (JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('number')
+               AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '100.0'::jsonb))
+          AND "posthog_person"."properties" ? ';''" SELECT 1; DROP TABLE posthog_featureflag;'
+          AND NOT (("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') = 'null'::jsonb)) AS "flag_X_condition_1",
+         (((("posthog_person"."properties" -> 'version!!!') > '"1.05"'::jsonb
+            AND JSONB_TYPEOF(("posthog_person"."properties" -> 'version!!!')) = ('string'))
+           OR (("posthog_person"."properties" -> 'version!!!') > '1.05'::jsonb
+               AND JSONB_TYPEOF(("posthog_person"."properties" -> 'version!!!')) = ('number')))
+          AND "posthog_person"."properties" ? 'version!!!'
+          AND NOT (("posthog_person"."properties" -> 'version!!!') = 'null'::jsonb)) AS "flag_X_condition_2",
+         ((("posthog_person"."properties" -> 'nested_prop --random #comment //test') = '"21"'::jsonb
+           OR ("posthog_person"."properties" -> 'nested_prop --random #comment //test') = '21'::jsonb)
+          AND "posthog_person"."properties" ? 'nested_prop --random #comment //test'
+          AND NOT (("posthog_person"."properties" -> 'nested_prop --random #comment //test') = 'null'::jsonb)) AS "flag_X_condition_3"
+  FROM "posthog_person"
+  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
+  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
+         AND "posthog_persondistinctid"."team_id" = 99999
+         AND "posthog_person"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_numeric_operator_with_groups_and_person_flags.3
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.2
   '''
-  SELECT (("posthog_group"."group_properties" -> 'number') > '"100b2c"'::jsonb
-          AND "posthog_group"."group_properties" ? 'number'
-          AND NOT (("posthog_group"."group_properties" -> 'number') = 'null'::jsonb)) AS "flag_X_condition_0"
-  FROM "posthog_group"
-  WHERE ("posthog_group"."team_id" = 99999
-         AND "posthog_group"."group_key" = 'foo-project'
-         AND "posthog_group"."group_type_index" = 1)
+  SELECT "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_team"
+  WHERE "posthog_team"."id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_super_condition_matches_string
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.3
   '''
-  SELECT ((("posthog_person"."properties" -> 'is_enabled') = 'true'::jsonb
-           OR ("posthog_person"."properties" -> 'is_enabled') = '"true"'::jsonb)
-          AND "posthog_person"."properties" ? 'is_enabled'
-          AND NOT (("posthog_person"."properties" -> 'is_enabled') = 'null'::jsonb)) AS "flag_X_super_condition", ("posthog_person"."properties" -> 'is_enabled') IS NOT NULL AS "flag_X_super_condition_is_set",
-                                                                                                                                                                                 (("posthog_person"."properties" -> 'email') = '"fake@posthog.com"'::jsonb
-                                                                                                                                                                                  AND "posthog_person"."properties" ? 'email'
-                                                                                                                                                                                  AND NOT (("posthog_person"."properties" -> 'email') = 'null'::jsonb)) AS "flag_X_condition_0",
-                                                                                                                                                                                 (("posthog_person"."properties" -> 'email') = '"test@posthog.com"'::jsonb
-                                                                                                                                                                                  AND "posthog_person"."properties" ? 'email'
-                                                                                                                                                                                  AND NOT (("posthog_person"."properties" -> 'email') = 'null'::jsonb)) AS "flag_X_condition_1",
-                                                                                                                                                                                 (true) AS "flag_X_condition_2"
-  FROM "posthog_person"
-  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = 'test_id'
-         AND "posthog_persondistinctid"."team_id" = 99999
-         AND "posthog_person"."team_id" = 99999)
+  SELECT "posthog_remoteconfig"."id",
+         "posthog_remoteconfig"."team_id",
+         "posthog_remoteconfig"."config",
+         "posthog_remoteconfig"."updated_at",
+         "posthog_remoteconfig"."synced_at"
+  FROM "posthog_remoteconfig"
+  WHERE "posthog_remoteconfig"."team_id" = 99999
+  LIMIT 21
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.4
   '''
   SELECT "posthog_team"."id",
          "posthog_team"."uuid",
@@ -713,9 +2396,47 @@
   LIMIT 21
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.1
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.5
   '''
-  SELECT "posthog_featureflag"."id",
+  SELECT COUNT(*) AS "__count"
+  FROM "posthog_featureflag"
+  WHERE ("posthog_featureflag"."active"
+         AND NOT "posthog_featureflag"."deleted"
+         AND "posthog_featureflag"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.6
+  '''
+  SELECT "posthog_survey"."id",
+         "posthog_survey"."team_id",
+         "posthog_survey"."name",
+         "posthog_survey"."description",
+         "posthog_survey"."linked_flag_id",
+         "posthog_survey"."targeting_flag_id",
+         "posthog_survey"."internal_targeting_flag_id",
+         "posthog_survey"."internal_response_sampling_flag_id",
+         "posthog_survey"."type",
+         "posthog_survey"."conditions",
+         "posthog_survey"."questions",
+         "posthog_survey"."appearance",
+         "posthog_survey"."created_at",
+         "posthog_survey"."created_by_id",
+         "posthog_survey"."start_date",
+         "posthog_survey"."end_date",
+         "posthog_survey"."updated_at",
+         "posthog_survey"."archived",
+         "posthog_survey"."responses_limit",
+         "posthog_survey"."response_sampling_start_date",
+         "posthog_survey"."response_sampling_interval_type",
+         "posthog_survey"."response_sampling_interval",
+         "posthog_survey"."response_sampling_limit",
+         "posthog_survey"."response_sampling_daily_limits",
+         "posthog_survey"."iteration_count",
+         "posthog_survey"."iteration_frequency_days",
+         "posthog_survey"."iteration_start_dates",
+         "posthog_survey"."current_iteration",
+         "posthog_survey"."current_iteration_start_date",
+         "posthog_featureflag"."id",
          "posthog_featureflag"."key",
          "posthog_featureflag"."name",
          "posthog_featureflag"."filters",
@@ -729,14 +2450,156 @@
          "posthog_featureflag"."performed_rollback",
          "posthog_featureflag"."ensure_experience_continuity",
          "posthog_featureflag"."usage_dashboard_id",
-         "posthog_featureflag"."has_enriched_analytics"
-  FROM "posthog_featureflag"
-  WHERE ("posthog_featureflag"."active"
-         AND NOT "posthog_featureflag"."deleted"
-         AND "posthog_featureflag"."team_id" = 99999)
+         "posthog_featureflag"."has_enriched_analytics",
+         T4."id",
+         T4."key",
+         T4."name",
+         T4."filters",
+         T4."rollout_percentage",
+         T4."team_id",
+         T4."created_by_id",
+         T4."created_at",
+         T4."deleted",
+         T4."active",
+         T4."rollback_conditions",
+         T4."performed_rollback",
+         T4."ensure_experience_continuity",
+         T4."usage_dashboard_id",
+         T4."has_enriched_analytics",
+         T5."id",
+         T5."key",
+         T5."name",
+         T5."filters",
+         T5."rollout_percentage",
+         T5."team_id",
+         T5."created_by_id",
+         T5."created_at",
+         T5."deleted",
+         T5."active",
+         T5."rollback_conditions",
+         T5."performed_rollback",
+         T5."ensure_experience_continuity",
+         T5."usage_dashboard_id",
+         T5."has_enriched_analytics"
+  FROM "posthog_survey"
+  LEFT OUTER JOIN "posthog_featureflag" ON ("posthog_survey"."linked_flag_id" = "posthog_featureflag"."id")
+  LEFT OUTER JOIN "posthog_featureflag" T4 ON ("posthog_survey"."targeting_flag_id" = T4."id")
+  LEFT OUTER JOIN "posthog_featureflag" T5 ON ("posthog_survey"."internal_targeting_flag_id" = T5."id")
+  WHERE ("posthog_survey"."team_id" = 99999
+         AND NOT ("posthog_survey"."archived"))
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.7
+  '''
+  SELECT "posthog_pluginconfig"."id",
+         "posthog_pluginsourcefile"."transpiled",
+         "posthog_pluginconfig"."web_token",
+         "posthog_plugin"."config_schema",
+         "posthog_pluginconfig"."config"
+  FROM "posthog_pluginconfig"
+  INNER JOIN "posthog_plugin" ON ("posthog_pluginconfig"."plugin_id" = "posthog_plugin"."id")
+  INNER JOIN "posthog_pluginsourcefile" ON ("posthog_plugin"."id" = "posthog_pluginsourcefile"."plugin_id")
+  WHERE ("posthog_pluginconfig"."enabled"
+         AND "posthog_pluginsourcefile"."filename" = 'site.ts'
+         AND "posthog_pluginsourcefile"."status" = 'TRANSPILED'
+         AND "posthog_pluginconfig"."team_id" = 99999)
+  '''
+# ---
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.8
+  '''
+  SELECT "posthog_hogfunction"."id",
+         "posthog_hogfunction"."team_id",
+         "posthog_hogfunction"."name",
+         "posthog_hogfunction"."description",
+         "posthog_hogfunction"."created_at",
+         "posthog_hogfunction"."created_by_id",
+         "posthog_hogfunction"."deleted",
+         "posthog_hogfunction"."updated_at",
+         "posthog_hogfunction"."enabled",
+         "posthog_hogfunction"."type",
+         "posthog_hogfunction"."icon_url",
+         "posthog_hogfunction"."hog",
+         "posthog_hogfunction"."bytecode",
+         "posthog_hogfunction"."transpiled",
+         "posthog_hogfunction"."inputs_schema",
+         "posthog_hogfunction"."inputs",
+         "posthog_hogfunction"."encrypted_inputs",
+         "posthog_hogfunction"."filters",
+         "posthog_hogfunction"."mappings",
+         "posthog_hogfunction"."masking",
+         "posthog_hogfunction"."template_id",
+         "posthog_team"."id",
+         "posthog_team"."uuid",
+         "posthog_team"."organization_id",
+         "posthog_team"."project_id",
+         "posthog_team"."api_token",
+         "posthog_team"."app_urls",
+         "posthog_team"."name",
+         "posthog_team"."slack_incoming_webhook",
+         "posthog_team"."created_at",
+         "posthog_team"."updated_at",
+         "posthog_team"."anonymize_ips",
+         "posthog_team"."completed_snippet_onboarding",
+         "posthog_team"."has_completed_onboarding_for",
+         "posthog_team"."ingested_event",
+         "posthog_team"."autocapture_opt_out",
+         "posthog_team"."autocapture_web_vitals_opt_in",
+         "posthog_team"."autocapture_web_vitals_allowed_metrics",
+         "posthog_team"."autocapture_exceptions_opt_in",
+         "posthog_team"."autocapture_exceptions_errors_to_ignore",
+         "posthog_team"."person_processing_opt_out",
+         "posthog_team"."session_recording_opt_in",
+         "posthog_team"."session_recording_sample_rate",
+         "posthog_team"."session_recording_minimum_duration_milliseconds",
+         "posthog_team"."session_recording_linked_flag",
+         "posthog_team"."session_recording_network_payload_capture_config",
+         "posthog_team"."session_recording_url_trigger_config",
+         "posthog_team"."session_recording_url_blocklist_config",
+         "posthog_team"."session_recording_event_trigger_config",
+         "posthog_team"."session_replay_config",
+         "posthog_team"."survey_config",
+         "posthog_team"."capture_console_log_opt_in",
+         "posthog_team"."capture_performance_opt_in",
+         "posthog_team"."capture_dead_clicks",
+         "posthog_team"."surveys_opt_in",
+         "posthog_team"."heatmaps_opt_in",
+         "posthog_team"."session_recording_version",
+         "posthog_team"."signup_token",
+         "posthog_team"."is_demo",
+         "posthog_team"."access_control",
+         "posthog_team"."week_start_day",
+         "posthog_team"."inject_web_apps",
+         "posthog_team"."test_account_filters",
+         "posthog_team"."test_account_filters_default_checked",
+         "posthog_team"."path_cleaning_filters",
+         "posthog_team"."timezone",
+         "posthog_team"."data_attributes",
+         "posthog_team"."person_display_name_properties",
+         "posthog_team"."live_events_columns",
+         "posthog_team"."recording_domains",
+         "posthog_team"."primary_dashboard_id",
+         "posthog_team"."extra_settings",
+         "posthog_team"."modifiers",
+         "posthog_team"."correlation_config",
+         "posthog_team"."session_recording_retention_period_days",
+         "posthog_team"."plugins_opt_in",
+         "posthog_team"."opt_out_capture",
+         "posthog_team"."event_names",
+         "posthog_team"."event_names_with_usage",
+         "posthog_team"."event_properties",
+         "posthog_team"."event_properties_with_usage",
+         "posthog_team"."event_properties_numerical",
+         "posthog_team"."external_data_workspace_id",
+         "posthog_team"."external_data_workspace_last_synced_at"
+  FROM "posthog_hogfunction"
+  INNER JOIN "posthog_team" ON ("posthog_hogfunction"."team_id" = "posthog_team"."id")
+  WHERE ("posthog_hogfunction"."enabled"
+         AND "posthog_hogfunction"."team_id" = 99999
+         AND "posthog_hogfunction"."type" IN ('site_destination',
+                                              'site_app'))
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.2
+# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.9
   '''
   SELECT "posthog_cohort"."id",
          "posthog_cohort"."name",
@@ -761,43 +2624,6 @@
          AND "posthog_cohort"."team_id" = 99999)
   '''
 # ---
-# name: TestFeatureFlagMatcher.test_with_sql_injection_properties_and_other_aliases.3
-  '''
-  SELECT (((("posthog_person"."properties" -> 'number space') > '"100"'::jsonb
-            AND JSONB_TYPEOF(("posthog_person"."properties" -> 'number space')) = ('string'))
-           OR (("posthog_person"."properties" -> 'number space') > '100.0'::jsonb
-               AND JSONB_TYPEOF(("posthog_person"."properties" -> 'number space')) = ('number')))
-          AND "posthog_person"."properties" ? 'number space'
-          AND NOT (("posthog_person"."properties" -> 'number space') = 'null'::jsonb)
-          AND ((JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('string')
-                AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '"100"'::jsonb)
-               OR (JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('number')
-                   AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '100.0'::jsonb))
-          AND "posthog_person"."properties" ? ';''" SELECT 1; DROP TABLE posthog_featureflag;'
-          AND NOT (("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') = 'null'::jsonb)) AS "flag_X_condition_0",
-         (((JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('string')
-            AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '"100"'::jsonb)
-           OR (JSONB_TYPEOF(("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;')) = ('number')
-               AND ("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') > '100.0'::jsonb))
-          AND "posthog_person"."properties" ? ';''" SELECT 1; DROP TABLE posthog_featureflag;'
-          AND NOT (("posthog_person"."properties" -> ';''" SELECT 1; DROP TABLE posthog_featureflag;') = 'null'::jsonb)) AS "flag_X_condition_1",
-         (((("posthog_person"."properties" -> 'version!!!') > '"1.05"'::jsonb
-            AND JSONB_TYPEOF(("posthog_person"."properties" -> 'version!!!')) = ('string'))
-           OR (("posthog_person"."properties" -> 'version!!!') > '1.05'::jsonb
-               AND JSONB_TYPEOF(("posthog_person"."properties" -> 'version!!!')) = ('number')))
-          AND "posthog_person"."properties" ? 'version!!!'
-          AND NOT (("posthog_person"."properties" -> 'version!!!') = 'null'::jsonb)) AS "flag_X_condition_2",
-         ((("posthog_person"."properties" -> 'nested_prop --random #comment //test') = '"21"'::jsonb
-           OR ("posthog_person"."properties" -> 'nested_prop --random #comment //test') = '21'::jsonb)
-          AND "posthog_person"."properties" ? 'nested_prop --random #comment //test'
-          AND NOT (("posthog_person"."properties" -> 'nested_prop --random #comment //test') = 'null'::jsonb)) AS "flag_X_condition_3"
-  FROM "posthog_person"
-  INNER JOIN "posthog_persondistinctid" ON ("posthog_person"."id" = "posthog_persondistinctid"."person_id")
-  WHERE ("posthog_persondistinctid"."distinct_id" = '307'
-         AND "posthog_persondistinctid"."team_id" = 99999
-         AND "posthog_person"."team_id" = 99999)
-  '''
-# ---
 # name: TestHashKeyOverridesRaceConditions.test_hash_key_overrides_with_simulated_error_race_conditions_on_person_merging
   'BEGIN'
 # ---
diff --git a/posthog/test/base.py b/posthog/test/base.py
index 43dcc0e130964..dc0760f4a3b5b 100644
--- a/posthog/test/base.py
+++ b/posthog/test/base.py
@@ -30,7 +30,6 @@
 from posthog import rate_limit, redis
 from posthog.clickhouse.client import sync_execute
 from posthog.clickhouse.client.connection import ch_pool
-from posthog.clickhouse.materialized_columns import get_materialized_columns
 from posthog.clickhouse.plugin_log_entries import TRUNCATE_PLUGIN_LOG_ENTRIES_TABLE_SQL
 from posthog.cloud_utils import TEST_clear_instance_license_cache
 from posthog.models import Dashboard, DashboardTile, Insight, Organization, Team, User
@@ -121,6 +120,8 @@ def clean_varying_query_parts(query, replace_all_numbers):
 
     else:
         query = re.sub(r"(team|cohort)_id(\"?) = \d+", r"\1_id\2 = 99999", query)
+        query = re.sub(r"(team|cohort)_id(\"?) IN \(\d+(, ?\d+)*\)", r"\1_id\2 IN (1, 2, 3, 4, 5 /* ... */)", query)
+        query = re.sub(r"(team|cohort)_id(\"?) IN \[\d+(, ?\d+)*\]", r"\1_id\2 IN [1, 2, 3, 4, 5 /* ... */]", query)
         query = re.sub(r"\d+ as (team|cohort)_id(\"?)", r"99999 as \1_id\2", query)
     # feature flag conditions use primary keys as columns in queries, so replace those always
     query = re.sub(r"flag_\d+_condition", r"flag_X_condition", query)
@@ -142,8 +143,8 @@ def clean_varying_query_parts(query, replace_all_numbers):
     )
     # replace arrays like "survey_id in ['017e12ef-9c00-0000-59bf-43ddb0bddea6', '017e12ef-9c00-0001-6df6-2cf1f217757f']"
     query = re.sub(
-        r"\"posthog_survey_actions\".\"survey_id\" IN \('[^']+'::uuid, '[^']+'::uuid\)",
-        r"'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid, '00000000-0000-0000-0000-000000000001'::uuid)",
+        r"\"posthog_survey_actions\"\.\"survey_id\" IN \('[^']+'::uuid(, '[^']+'::uuid)*\)",
+        r"'posthog_survey_actions'.'survey_id' IN ('00000000-0000-0000-0000-000000000000'::uuid, '00000000-0000-0000-0000-000000000001'::uuid, /* ... */])",
         query,
     )
     # replace session uuids
@@ -156,7 +157,7 @@ def clean_varying_query_parts(query, replace_all_numbers):
     #### Cohort replacements
     # replace cohort id lists in queries too
     query = re.sub(
-        r"in\(([^,]+\.?cohort_id), \[(\d+(, ?\d+)*)]\)",
+        r"in\(([^,]*cohort_id),\s*\[(\d+(?:,\s*\d+)*)]\)",
         r"in(\1, [1, 2, 3, 4, 5 /* ... */])",
         query,
     )
@@ -575,35 +576,31 @@ def stripResponse(response, remove=("action", "label", "persons_urls", "filter")
     return response
 
 
-def default_materialised_columns():
+def cleanup_materialized_columns():
     try:
+        from ee.clickhouse.materialized_columns.columns import get_materialized_columns
         from ee.clickhouse.materialized_columns.test.test_columns import EVENTS_TABLE_DEFAULT_MATERIALIZED_COLUMNS
     except:
         # EE not available? Skip
-        return []
-
-    default_columns = []
-    for prop in EVENTS_TABLE_DEFAULT_MATERIALIZED_COLUMNS:
-        column_name = get_materialized_columns("events")[(prop, "properties")]
-        default_columns.append(column_name)
-
-    return default_columns
+        return
 
-
-def cleanup_materialized_columns():
     def optionally_drop(table, filter=None):
         drops = ",".join(
             [
-                f"DROP COLUMN {column_name}"
-                for column_name in get_materialized_columns(table).values()
-                if filter is None or filter(column_name)
+                f"DROP COLUMN {column.name}"
+                for column in get_materialized_columns(table).values()
+                if filter is None or filter(column.name)
             ]
         )
         if drops:
             sync_execute(f"ALTER TABLE {table} {drops} SETTINGS mutations_sync = 2")
 
-    default_columns = default_materialised_columns()
-    optionally_drop("events", lambda name: name not in default_columns)
+    default_column_names = {
+        get_materialized_columns("events")[(prop, "properties")].name
+        for prop in EVENTS_TABLE_DEFAULT_MATERIALIZED_COLUMNS
+    }
+
+    optionally_drop("events", lambda name: name not in default_column_names)
     optionally_drop("person")
     optionally_drop("groups")
 
@@ -795,6 +792,14 @@ def _execute_migration_with_snapshots(self, executor):
     def setUpBeforeMigration(self, apps):
         pass
 
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()  # type: ignore
+        executor = MigrationExecutor(connection)  # Reset Django's migration state
+        targets = executor.loader.graph.leaf_nodes()
+        executor.migrate(targets)  # Migrate to the latest migration
+        executor.loader.build_graph()  # Reload.
+
 
 class TestMigrations(BaseTestMigrations, BaseTest):
     """
diff --git a/posthog/test/test_middleware.py b/posthog/test/test_middleware.py
index e6a9e95ac9ba0..2d987bc2795e1 100644
--- a/posthog/test/test_middleware.py
+++ b/posthog/test/test_middleware.py
@@ -501,7 +501,8 @@ def test_logout(self):
         self.assertNotIn("ph_current_project_name", response.cookies)
 
 
-@override_settings(IMPERSONATION_TIMEOUT_SECONDS=30)
+@override_settings(IMPERSONATION_TIMEOUT_SECONDS=100)
+@override_settings(IMPERSONATION_IDLE_TIMEOUT_SECONDS=20)
 class TestAutoLogoutImpersonateMiddleware(APIBaseTest):
     other_user: User
 
@@ -538,21 +539,65 @@ def test_not_staff_user_cannot_login(self):
         assert response.status_code == 200
         assert self.client.get("/api/users/@me").json()["email"] == self.user.email
 
-    def test_after_timeout_api_requests_401(self):
-        now = datetime.now()
+    def test_after_idle_timeout_api_requests_401(self):
+        now = datetime(2024, 1, 1, 12, 0, 0)
         with freeze_time(now):
             self.login_as_other_user()
             res = self.client.get("/api/users/@me")
             assert res.status_code == 200
             assert res.json()["email"] == "other-user@posthog.com"
+            assert res.json()["is_impersonated_until"] == "2024-01-01T12:00:20+00:00"
             assert self.client.session.get("session_created_at") == now.timestamp()
 
-        with freeze_time(now + timedelta(seconds=10)):
+        # Move forward by 19
+        now = now + timedelta(seconds=19)
+        with freeze_time(now):
             res = self.client.get("/api/users/@me")
             assert res.status_code == 200
             assert res.json()["email"] == "other-user@posthog.com"
+            assert res.json()["is_impersonated_until"] == "2024-01-01T12:00:39+00:00"
 
-        with freeze_time(now + timedelta(seconds=35)):
+        # Past idle timeout
+        now = now + timedelta(seconds=21)
+
+        with freeze_time(now):
+            res = self.client.get("/api/users/@me")
+            assert res.status_code == 401
+
+    def test_after_total_timeout_api_requests_401(self):
+        now = datetime(2024, 1, 1, 12, 0, 0)
+        with freeze_time(now):
+            self.login_as_other_user()
+            res = self.client.get("/api/users/@me")
+            assert res.status_code == 200
+            assert res.json()["email"] == "other-user@posthog.com"
+            assert res.json()["is_impersonated_until"] == "2024-01-01T12:00:20+00:00"
+            assert self.client.session.get("session_created_at") == now.timestamp()
+
+        for _ in range(4):
+            # Move forward by 19 seconds 4 times for a total of 76 seconds
+            now = now + timedelta(seconds=19)
+            with freeze_time(now):
+                res = self.client.get("/api/users/@me")
+                assert res.status_code == 200
+                assert res.json()["email"] == "other-user@posthog.com"
+                # Format exactly like the date above
+                assert res.json()["is_impersonated_until"] == (now + timedelta(seconds=20)).strftime(
+                    "%Y-%m-%dT%H:%M:%S+00:00"
+                )
+
+        now = now + timedelta(seconds=19)
+        with freeze_time(now):
+            res = self.client.get("/api/users/@me")
+            assert res.status_code == 200
+            assert res.json()["email"] == "other-user@posthog.com"
+            # Even though below the idle timeout, we now see the total timeout as that is earlier
+            assert res.json()["is_impersonated_until"] == "2024-01-01T12:01:40+00:00"
+
+        # Now even less than the idle time will take us past the total timeout
+        now = now + timedelta(seconds=10)
+
+        with freeze_time(now):
             res = self.client.get("/api/users/@me")
             assert res.status_code == 401
 
diff --git a/posthog/test/test_schema_helpers.py b/posthog/test/test_schema_helpers.py
index a7a7303f57a20..38ef8866ebce5 100644
--- a/posthog/test/test_schema_helpers.py
+++ b/posthog/test/test_schema_helpers.py
@@ -129,7 +129,7 @@ def _assert_filter(self, key: str, num_keys: int, q1: BaseModel, q2: BaseModel):
 
     @parameterized.expand(
         [
-            ({}, {"date_from": "-7d", "explicitDate": False}, 0),
+            ({}, {"explicitDate": False}, 0),
             ({"date_to": "2024-02-02"}, {"date_to": "2024-02-02"}, 1),
         ]
     )
diff --git a/posthog/udf_versioner.py b/posthog/udf_versioner.py
index 4b9554dba90a7..50011d1d94c5b 100644
--- a/posthog/udf_versioner.py
+++ b/posthog/udf_versioner.py
@@ -13,10 +13,10 @@
 # 4. Land a version of the posthog repo with the updated `user_scripts` folder from the new branch (make sure this PR doesn't include changes to this file with the new version)
 # 5. Run the `copy_udfs_to_clickhouse` action in the `posthog_cloud_infra` repo to deploy the `user_scripts` folder to clickhouse
 # 6. After that deploy goes out, it is safe to land and deploy the full changes to the `posthog` repo
-UDF_VERSION = 3  # Last modified by: @aspicer, 2024-10-30
+UDF_VERSION = 4  # Last modified by: @aspicer, 2024-12-6
 
 # Clean up all versions less than this
-EARLIEST_UDF_VERSION = 2
+EARLIEST_UDF_VERSION = 3
 
 CLICKHOUSE_XML_FILENAME = "user_defined_function.xml"
 ACTIVE_XML_CONFIG = "../../docker/clickhouse/user_defined_function.xml"
diff --git a/posthog/urls.py b/posthog/urls.py
index 210287c149392..9a1f46757e892 100644
--- a/posthog/urls.py
+++ b/posthog/urls.py
@@ -29,6 +29,7 @@
     capture,
     decide,
     hog_function_template,
+    remote_config,
     router,
     sharing,
     signup,
@@ -210,7 +211,9 @@ def opt_slash_path(route: str, view: Callable, name: Optional[str] = None) -> UR
         sharing.SharingViewerPageViewSet.as_view({"get": "retrieve"}),
     ),
     path("site_app/<int:id>/<str:token>/<str:hash>/", site_app.get_site_app),
-    path("site_function/<str:id>/<str:hash>/", site_app.get_site_function),
+    path("array/<str:token>/config", remote_config.RemoteConfigAPIView.as_view()),
+    path("array/<str:token>/config.js", remote_config.RemoteConfigJSAPIView.as_view()),
+    path("array/<str:token>/array.js", remote_config.RemoteConfigArrayJSAPIView.as_view()),
     re_path(r"^demo.*", login_required(demo_route)),
     # ingestion
     # NOTE: When adding paths here that should be public make sure to update ALWAYS_ALLOWED_ENDPOINTS in middleware.py
@@ -234,6 +237,8 @@ def opt_slash_path(route: str, view: Callable, name: Optional[str] = None) -> UR
     path("year_in_posthog/2022/<str:user_uuid>/", year_in_posthog.render_2022),
     path("year_in_posthog/2023/<str:user_uuid>", year_in_posthog.render_2023),
     path("year_in_posthog/2023/<str:user_uuid>/", year_in_posthog.render_2023),
+    path("year_in_posthog/2024/<str:user_uuid>", year_in_posthog.render_2024),
+    path("year_in_posthog/2024/<str:user_uuid>/", year_in_posthog.render_2024),
 ]
 
 if settings.DEBUG:
diff --git a/posthog/user_scripts/aggregate_funnel_aarch64 b/posthog/user_scripts/aggregate_funnel_aarch64
index 6c490d2e58b86..470c0e61a820b 100755
Binary files a/posthog/user_scripts/aggregate_funnel_aarch64 and b/posthog/user_scripts/aggregate_funnel_aarch64 differ
diff --git a/posthog/user_scripts/aggregate_funnel_x86_64 b/posthog/user_scripts/aggregate_funnel_x86_64
index 9570bf6d55e29..fed097f05fe0a 100755
Binary files a/posthog/user_scripts/aggregate_funnel_x86_64 and b/posthog/user_scripts/aggregate_funnel_x86_64 differ
diff --git a/posthog/user_scripts/latest_user_defined_function.xml b/posthog/user_scripts/latest_user_defined_function.xml
index a7da950ae23e2..95af85d63412f 100644
--- a/posthog/user_scripts/latest_user_defined_function.xml
+++ b/posthog/user_scripts/latest_user_defined_function.xml
@@ -1,8 +1,8 @@
 <functions>
-    <!-- Version: v3. Generated at: 2024-10-30T21:06:46.087998+00:00
+    <!-- Version: v4. Generated at: 2024-12-10T05:06:27.315812+00:00
 This file is autogenerated by udf_versioner.py. Do not edit this, only edit the version at docker/clickhouse/user_defined_function.xml--><function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_v2</name>
+        <name>aggregate_funnel_v3</name>
         <return_type>Array(Tuple(Int8, Nullable(String), Array(Float64), Array(Array(UUID))))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -30,13 +30,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel steps</command>
+        <command>v3/aggregate_funnel steps</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_cohort_v2</name>
+        <name>aggregate_funnel_cohort_v3</name>
         <return_type>Array(Tuple(Int8, UInt64, Array(Float64), Array(Array(UUID))))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -64,13 +64,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel steps</command>
+        <command>v3/aggregate_funnel steps</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_array_v2</name>
+        <name>aggregate_funnel_array_v3</name>
         <return_type>Array(Tuple(Int8, Array(String), Array(Float64), Array(Array(UUID))))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -98,13 +98,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel steps</command>
+        <command>v3/aggregate_funnel steps</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_test_v2</name>
+        <name>aggregate_funnel_test_v3</name>
         <return_type>String</return_type>
         <return_name>result</return_name>
         <argument>
@@ -132,13 +132,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel_test.py</command>
+        <command>v3/aggregate_funnel_test.py</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_trends_v2</name>
+        <name>aggregate_funnel_trends_v3</name>
         <return_type>Array(Tuple(UInt64, Int8, Nullable(String), UUID))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -174,13 +174,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel trends</command>
+        <command>v3/aggregate_funnel trends</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_array_trends_v2</name>
+        <name>aggregate_funnel_array_trends_v3</name>
         
         <return_type>Array(Tuple(UInt64, Int8, Array(String), UUID))</return_type>
         <return_name>result</return_name>
@@ -213,13 +213,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel trends</command>
+        <command>v3/aggregate_funnel trends</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_cohort_trends_v2</name>
+        <name>aggregate_funnel_cohort_trends_v3</name>
         
         <return_type>Array(Tuple(UInt64, Int8, UInt64, UUID))</return_type>
         <return_name>result</return_name>
@@ -252,13 +252,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel trends</command>
+        <command>v3/aggregate_funnel trends</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_array_trends_test_v2</name>
+        <name>aggregate_funnel_array_trends_test_v3</name>
         <return_type>String</return_type>
         <return_name>result</return_name>
         <argument>
@@ -290,12 +290,12 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v2/aggregate_funnel_array_trends_test.py</command>
+        <command>v3/aggregate_funnel_array_trends_test.py</command>
         <lifetime>600</lifetime>
     </function>
 <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_v3</name>
+        <name>aggregate_funnel_v4</name>
         <return_type>Array(Tuple(Int8, Nullable(String), Array(Float64), Array(Array(UUID))))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -323,13 +323,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel steps</command>
+        <command>v4/aggregate_funnel steps</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_cohort_v3</name>
+        <name>aggregate_funnel_cohort_v4</name>
         <return_type>Array(Tuple(Int8, UInt64, Array(Float64), Array(Array(UUID))))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -357,13 +357,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel steps</command>
+        <command>v4/aggregate_funnel steps</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_array_v3</name>
+        <name>aggregate_funnel_array_v4</name>
         <return_type>Array(Tuple(Int8, Array(String), Array(Float64), Array(Array(UUID))))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -391,13 +391,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel steps</command>
+        <command>v4/aggregate_funnel steps</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_test_v3</name>
+        <name>aggregate_funnel_test_v4</name>
         <return_type>String</return_type>
         <return_name>result</return_name>
         <argument>
@@ -425,13 +425,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel_test.py</command>
+        <command>v4/aggregate_funnel_test.py</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_trends_v3</name>
+        <name>aggregate_funnel_trends_v4</name>
         <return_type>Array(Tuple(UInt64, Int8, Nullable(String), UUID))</return_type>
         <return_name>result</return_name>
         <argument>
@@ -467,13 +467,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel trends</command>
+        <command>v4/aggregate_funnel trends</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_array_trends_v3</name>
+        <name>aggregate_funnel_array_trends_v4</name>
         
         <return_type>Array(Tuple(UInt64, Int8, Array(String), UUID))</return_type>
         <return_name>result</return_name>
@@ -506,13 +506,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel trends</command>
+        <command>v4/aggregate_funnel trends</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_cohort_trends_v3</name>
+        <name>aggregate_funnel_cohort_trends_v4</name>
         
         <return_type>Array(Tuple(UInt64, Int8, UInt64, UUID))</return_type>
         <return_name>result</return_name>
@@ -545,13 +545,13 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel trends</command>
+        <command>v4/aggregate_funnel trends</command>
         <lifetime>600</lifetime>
     </function>
 
     <function>
         <type>executable_pool</type>
-        <name>aggregate_funnel_array_trends_test_v3</name>
+        <name>aggregate_funnel_array_trends_test_v4</name>
         <return_type>String</return_type>
         <return_name>result</return_name>
         <argument>
@@ -583,7 +583,7 @@ This file is autogenerated by udf_versioner.py. Do not edit this, only edit the
             <name>value</name>
         </argument>
         <format>JSONEachRow</format>
-        <command>v3/aggregate_funnel_array_trends_test.py</command>
+        <command>v4/aggregate_funnel_array_trends_test.py</command>
         <lifetime>600</lifetime>
     </function>
 </functions>
\ No newline at end of file
diff --git a/posthog/user_scripts/v4/aggregate_funnel b/posthog/user_scripts/v4/aggregate_funnel
new file mode 100755
index 0000000000000..e62dd751484cb
--- /dev/null
+++ b/posthog/user_scripts/v4/aggregate_funnel
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+DIR_NAME=$(dirname "$0")
+
+case $( uname -m ) in
+aarch64) $DIR_NAME/aggregate_funnel_aarch64 "$@";;
+*) $DIR_NAME/aggregate_funnel_x86_64 "$@";;
+esac
+
diff --git a/posthog/user_scripts/v4/aggregate_funnel_aarch64 b/posthog/user_scripts/v4/aggregate_funnel_aarch64
new file mode 100755
index 0000000000000..470c0e61a820b
Binary files /dev/null and b/posthog/user_scripts/v4/aggregate_funnel_aarch64 differ
diff --git a/posthog/user_scripts/v4/aggregate_funnel_array_trends_test.py b/posthog/user_scripts/v4/aggregate_funnel_array_trends_test.py
new file mode 100755
index 0000000000000..cf6ab4e33741b
--- /dev/null
+++ b/posthog/user_scripts/v4/aggregate_funnel_array_trends_test.py
@@ -0,0 +1,13 @@
+#!/usr/bin/python3
+
+import sys
+import json
+
+if __name__ == "__main__":
+    for line in sys.stdin:
+        try:
+            print(json.dumps({"result": line}))  # noqa: T201
+            # calculate_funnel_trends_from_user_events(*parse_args(line))
+        except Exception as e:
+            print(json.dumps({"result": json.dumps(str(e))}), end="\n")  # noqa: T201
+        sys.stdout.flush()
diff --git a/posthog/user_scripts/v4/aggregate_funnel_test.py b/posthog/user_scripts/v4/aggregate_funnel_test.py
new file mode 100755
index 0000000000000..1eae7c9f36914
--- /dev/null
+++ b/posthog/user_scripts/v4/aggregate_funnel_test.py
@@ -0,0 +1,14 @@
+#!/usr/bin/python3
+import json
+
+import sys
+import traceback
+
+if __name__ == "__main__":
+    for line in sys.stdin:
+        try:
+            # calculate_funnel_from_user_events(*parse_args(line))
+            print(json.dumps({"result": line}))  # noqa: T201
+        except Exception as e:
+            print(json.dumps({"result": json.dumps(str(e) + traceback.format_exc())}), end="\n")  # noqa: T201
+        sys.stdout.flush()
diff --git a/posthog/user_scripts/v4/aggregate_funnel_x86_64 b/posthog/user_scripts/v4/aggregate_funnel_x86_64
new file mode 100755
index 0000000000000..fed097f05fe0a
Binary files /dev/null and b/posthog/user_scripts/v4/aggregate_funnel_x86_64 differ
diff --git a/posthog/user_scripts/v4/user_defined_function.xml b/posthog/user_scripts/v4/user_defined_function.xml
new file mode 100644
index 0000000000000..95af85d63412f
--- /dev/null
+++ b/posthog/user_scripts/v4/user_defined_function.xml
@@ -0,0 +1,589 @@
+<functions>
+    <!-- Version: v4. Generated at: 2024-12-10T05:06:27.315812+00:00
+This file is autogenerated by udf_versioner.py. Do not edit this, only edit the version at docker/clickhouse/user_defined_function.xml--><function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_v3</name>
+        <return_type>Array(Tuple(Int8, Nullable(String), Array(Float64), Array(Array(UUID))))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Nullable(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, Nullable(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel steps</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_cohort_v3</name>
+        <return_type>Array(Tuple(Int8, UInt64, Array(Float64), Array(Array(UUID))))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(UInt64)</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, UInt64, Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel steps</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_array_v3</name>
+        <return_type>Array(Tuple(Int8, Array(String), Array(Float64), Array(Array(UUID))))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, Array(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel steps</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_test_v3</name>
+        <return_type>String</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, Nullable(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel_test.py</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_trends_v3</name>
+        <return_type>Array(Tuple(UInt64, Int8, Nullable(String), UUID))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Nullable(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, Nullable(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel trends</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_array_trends_v3</name>
+        
+        <return_type>Array(Tuple(UInt64, Int8, Array(String), UUID))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, Array(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel trends</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_cohort_trends_v3</name>
+        
+        <return_type>Array(Tuple(UInt64, Int8, UInt64, UUID))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(UInt64)</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, UInt64, Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel trends</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_array_trends_test_v3</name>
+        <return_type>String</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, Array(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v3/aggregate_funnel_array_trends_test.py</command>
+        <lifetime>600</lifetime>
+    </function>
+<function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_v4</name>
+        <return_type>Array(Tuple(Int8, Nullable(String), Array(Float64), Array(Array(UUID))))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Nullable(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, Nullable(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel steps</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_cohort_v4</name>
+        <return_type>Array(Tuple(Int8, UInt64, Array(Float64), Array(Array(UUID))))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(UInt64)</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, UInt64, Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel steps</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_array_v4</name>
+        <return_type>Array(Tuple(Int8, Array(String), Array(Float64), Array(Array(UUID))))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, Array(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel steps</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_test_v4</name>
+        <return_type>String</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UUID, Nullable(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel_test.py</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_trends_v4</name>
+        <return_type>Array(Tuple(UInt64, Int8, Nullable(String), UUID))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Nullable(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, Nullable(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel trends</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_array_trends_v4</name>
+        
+        <return_type>Array(Tuple(UInt64, Int8, Array(String), UUID))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, Array(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel trends</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_cohort_trends_v4</name>
+        
+        <return_type>Array(Tuple(UInt64, Int8, UInt64, UUID))</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(UInt64)</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, UInt64, Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel trends</command>
+        <lifetime>600</lifetime>
+    </function>
+
+    <function>
+        <type>executable_pool</type>
+        <name>aggregate_funnel_array_trends_test_v4</name>
+        <return_type>String</return_type>
+        <return_name>result</return_name>
+        <argument>
+            <type>UInt8</type>
+            <name>from_step</name>
+        </argument>
+        <argument>
+            <type>UInt8</type>
+            <name>num_steps</name>
+        </argument>
+        <argument>
+            <type>UInt64</type>
+            <name>conversion_window_limit</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>breakdown_attribution_type</name>
+        </argument>
+        <argument>
+            <type>String</type>
+            <name>funnel_order_type</name>
+        </argument>
+        <argument>
+            <type>Array(Array(String))</type>
+            <name>prop_vals</name>
+        </argument>
+        <argument>
+            <type>Array(Tuple(Nullable(Float64), UInt64, UUID, Array(String), Array(Int8)))</type>
+            <name>value</name>
+        </argument>
+        <format>JSONEachRow</format>
+        <command>v4/aggregate_funnel_array_trends_test.py</command>
+        <lifetime>600</lifetime>
+    </function>
+</functions>
\ No newline at end of file
diff --git a/posthog/utils.py b/posthog/utils.py
index d8ea9315fec7c..5a22bfcdde9ff 100644
--- a/posthog/utils.py
+++ b/posthog/utils.py
@@ -348,7 +348,7 @@ def render_template(
     context["js_url"] = get_js_url(request)
 
     try:
-        year_in_hog_url = f"/year_in_posthog/2023/{str(request.user.uuid)}"  # type: ignore
+        year_in_hog_url = f"/year_in_posthog/2024/{str(request.user.uuid)}"  # type: ignore
     except:
         year_in_hog_url = None
 
diff --git a/posthog/warehouse/api/external_data_schema.py b/posthog/warehouse/api/external_data_schema.py
index 55a4447907021..9391268bb69d0 100644
--- a/posthog/warehouse/api/external_data_schema.py
+++ b/posthog/warehouse/api/external_data_schema.py
@@ -350,14 +350,23 @@ def incremental_fields(self, request: Request, *args: Any, **kwargs: Any):
             sf_schema = source.job_inputs.get("schema")
             role = source.job_inputs.get("role")
 
+            auth_type = source.job_inputs.get("auth_type", "password")
+            auth_type_username = source.job_inputs.get("user")
+            auth_type_password = source.job_inputs.get("password")
+            auth_type_passphrase = source.job_inputs.get("passphrase")
+            auth_type_private_key = source.job_inputs.get("private_key")
+
             sf_schemas = get_snowflake_schemas(
                 account_id=account_id,
                 database=database,
                 warehouse=warehouse,
-                user=user,
-                password=password,
+                user=auth_type_username,
+                password=auth_type_password,
                 schema=sf_schema,
                 role=role,
+                auth_type=auth_type,
+                passphrase=auth_type_passphrase,
+                private_key=auth_type_private_key,
             )
 
             columns = sf_schemas.get(instance.name, [])
diff --git a/posthog/warehouse/api/external_data_source.py b/posthog/warehouse/api/external_data_source.py
index cc1f38170d327..448c06533bf19 100644
--- a/posthog/warehouse/api/external_data_source.py
+++ b/posthog/warehouse/api/external_data_source.py
@@ -640,10 +640,15 @@ def _handle_snowflake_source(
         database = payload.get("database")
         warehouse = payload.get("warehouse")
         role = payload.get("role")
-        user = payload.get("user")
-        password = payload.get("password")
         schema = payload.get("schema")
 
+        auth_type_obj = payload.get("auth_type", {})
+        auth_type = auth_type_obj.get("selection", None)
+        auth_type_username = auth_type_obj.get("username", None)
+        auth_type_password = auth_type_obj.get("password", None)
+        auth_type_passphrase = auth_type_obj.get("passphrase", None)
+        auth_type_private_key = auth_type_obj.get("private_key", None)
+
         new_source_model = ExternalDataSource.objects.create(
             source_id=str(uuid.uuid4()),
             connection_id=str(uuid.uuid4()),
@@ -656,14 +661,28 @@ def _handle_snowflake_source(
                 "database": database,
                 "warehouse": warehouse,
                 "role": role,
-                "user": user,
-                "password": password,
                 "schema": schema,
+                "auth_type": auth_type,
+                "user": auth_type_username,
+                "password": auth_type_password,
+                "passphrase": auth_type_passphrase,
+                "private_key": auth_type_private_key,
             },
             prefix=prefix,
         )
 
-        schemas = get_snowflake_schemas(account_id, database, warehouse, user, password, schema, role)
+        schemas = get_snowflake_schemas(
+            account_id=account_id,
+            database=database,
+            warehouse=warehouse,
+            user=auth_type_username,
+            password=auth_type_password,
+            schema=schema,
+            role=role,
+            passphrase=auth_type_passphrase,
+            private_key=auth_type_private_key,
+            auth_type=auth_type,
+        )
 
         return new_source_model, list(schemas.keys())
 
@@ -1068,20 +1087,48 @@ def database_schema(self, request: Request, *arg: Any, **kwargs: Any):
             database = request.data.get("database")
             warehouse = request.data.get("warehouse")
             role = request.data.get("role")
-            user = request.data.get("user")
-            password = request.data.get("password")
             schema = request.data.get("schema")
 
-            if not account_id or not warehouse or not database or not user or not password or not schema:
+            auth_type_obj = request.data.get("auth_type", {})
+            auth_type = auth_type_obj.get("selection", None)
+            auth_type_username = auth_type_obj.get("username", None)
+            auth_type_password = auth_type_obj.get("password", None)
+            auth_type_passphrase = auth_type_obj.get("passphrase", None)
+            auth_type_private_key = auth_type_obj.get("private_key", None)
+
+            if not account_id or not warehouse or not database or not schema:
+                return Response(
+                    status=status.HTTP_400_BAD_REQUEST,
+                    data={"message": "Missing required parameters: account id, warehouse, database, schema"},
+                )
+
+            if auth_type == "password" and (not auth_type_username or not auth_type_password):
+                return Response(
+                    status=status.HTTP_400_BAD_REQUEST,
+                    data={"message": "Missing required parameters: username, password"},
+                )
+
+            if auth_type == "keypair" and (
+                not auth_type_passphrase or not auth_type_private_key or not auth_type_username
+            ):
                 return Response(
                     status=status.HTTP_400_BAD_REQUEST,
-                    data={
-                        "message": "Missing required parameters: account id, warehouse, database, user, password, schema"
-                    },
+                    data={"message": "Missing required parameters: passphrase, private key"},
                 )
 
             try:
-                result = get_snowflake_schemas(account_id, database, warehouse, user, password, schema, role)
+                result = get_snowflake_schemas(
+                    account_id=account_id,
+                    database=database,
+                    warehouse=warehouse,
+                    user=auth_type_username,
+                    password=auth_type_password,
+                    schema=schema,
+                    role=role,
+                    passphrase=auth_type_passphrase,
+                    private_key=auth_type_private_key,
+                    auth_type=auth_type,
+                )
                 if len(result.keys()) == 0:
                     return Response(
                         status=status.HTTP_400_BAD_REQUEST,
diff --git a/posthog/warehouse/models/external_data_schema.py b/posthog/warehouse/models/external_data_schema.py
index b8219a6628c02..3cb3fcfbce33c 100644
--- a/posthog/warehouse/models/external_data_schema.py
+++ b/posthog/warehouse/models/external_data_schema.py
@@ -1,8 +1,11 @@
 from collections import defaultdict
 from datetime import datetime, timedelta
-from typing import Optional
+import tempfile
+import os
+from typing import Any, Optional
 from django.db import models
 from django_deprecate_fields import deprecate_field
+import numpy
 import snowflake.connector
 from django.conf import settings
 from posthog.models.team import Team
@@ -72,6 +75,27 @@ def soft_delete(self):
         self.deleted_at = datetime.now()
         self.save()
 
+    def update_incremental_field_last_value(self, last_value: Any) -> None:
+        incremental_field_type = self.sync_type_config.get("incremental_field_type")
+
+        last_value_py = last_value.item() if isinstance(last_value, numpy.generic) else last_value
+
+        if (
+            incremental_field_type == IncrementalFieldType.Integer
+            or incremental_field_type == IncrementalFieldType.Numeric
+        ):
+            if isinstance(last_value_py, int | float):
+                last_value_json = last_value_py
+            elif isinstance(last_value_py, datetime):
+                last_value_json = str(last_value_py)
+            else:
+                last_value_json = int(last_value_py)
+        else:
+            last_value_json = str(last_value_py)
+
+        self.sync_type_config["incremental_field_last_value"] = last_value_json
+        self.save()
+
 
 @database_sync_to_async
 def asave_external_data_schema(schema: ExternalDataSchema) -> None:
@@ -193,16 +217,43 @@ def filter_snowflake_incremental_fields(columns: list[tuple[str, str]]) -> list[
 
 
 def get_snowflake_schemas(
-    account_id: str, database: str, warehouse: str, user: str, password: str, schema: str, role: Optional[str] = None
+    account_id: str,
+    database: str,
+    warehouse: str,
+    user: Optional[str],
+    password: Optional[str],
+    passphrase: Optional[str],
+    private_key: Optional[str],
+    auth_type: str,
+    schema: str,
+    role: Optional[str] = None,
 ) -> dict[str, list[tuple[str, str]]]:
+    auth_connect_args: dict[str, str | None] = {}
+    file_name: str | None = None
+
+    if auth_type == "keypair" and private_key is not None:
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            tf.write(private_key.encode("utf-8"))
+            file_name = tf.name
+
+        auth_connect_args = {
+            "user": user,
+            "private_key_file": file_name,
+            "private_key_file_pwd": passphrase,
+        }
+    else:
+        auth_connect_args = {
+            "password": password,
+            "user": user,
+        }
+
     with snowflake.connector.connect(
-        user=user,
-        password=password,
         account=account_id,
         warehouse=warehouse,
         database=database,
         schema="information_schema",
         role=role,
+        **auth_connect_args,
     ) as connection:
         with connection.cursor() as cursor:
             if cursor is None:
@@ -218,7 +269,10 @@ def get_snowflake_schemas(
             for row in result:
                 schema_list[row[0]].append((row[1], row[2]))
 
-            return schema_list
+    if file_name is not None:
+        os.unlink(file_name)
+
+    return schema_list
 
 
 def filter_postgres_incremental_fields(columns: list[tuple[str, str]]) -> list[tuple[str, IncrementalFieldType]]:
diff --git a/posthog/warehouse/models/join.py b/posthog/warehouse/models/join.py
index b24d6916e93c9..51108c58e578c 100644
--- a/posthog/warehouse/models/join.py
+++ b/posthog/warehouse/models/join.py
@@ -113,6 +113,27 @@ def _join_function_for_experiments(
             if not timestamp_key:
                 raise ResolutionError("experiments_timestamp_key is not set for this join")
 
+            whereExpr: list[ast.Expr] = [
+                ast.CompareOperation(
+                    op=ast.CompareOperationOp.Eq,
+                    left=ast.Field(chain=["event"]),
+                    right=ast.Constant(value="$feature_flag_called"),
+                )
+            ]
+            # :HACK: We need to pull the timestamp gt/lt values from node.where.exprs[0] because
+            # we can't reference the parent data warehouse table in the where clause.
+            if node.where and hasattr(node.where, "exprs"):
+                for expr in node.where.exprs:
+                    if isinstance(expr, ast.CompareOperation):
+                        if expr.op == ast.CompareOperationOp.GtEq or expr.op == ast.CompareOperationOp.LtEq:
+                            # Match within hogql string because it could be 'toDateTime(timestamp)'
+                            if isinstance(expr.left, ast.Alias) and timestamp_key in expr.left.expr.to_hogql():
+                                whereExpr.append(
+                                    ast.CompareOperation(
+                                        op=expr.op, left=ast.Field(chain=["timestamp"]), right=expr.right
+                                    )
+                                )
+
             return ast.JoinExpr(
                 table=ast.SelectQuery(
                     select=[
@@ -128,6 +149,7 @@ def _join_function_for_experiments(
                         }.items()
                     ],
                     select_from=ast.JoinExpr(table=ast.Field(chain=["events"])),
+                    where=ast.And(exprs=whereExpr),
                 ),
                 # ASOF JOIN finds the most recent matching event that occurred at or before each data warehouse timestamp.
                 #
@@ -162,7 +184,7 @@ def _join_function_for_experiments(
                                     ]
                                 ),
                                 op=ast.CompareOperationOp.Eq,
-                                right=ast.Field(chain=[join_to_add.to_table, "distinct_id"]),
+                                right=ast.Field(chain=[join_to_add.to_table, *self.joining_table_key.split(".")]),
                             ),
                             ast.CompareOperation(
                                 left=ast.Field(
diff --git a/posthog/year_in_posthog/2023.html b/posthog/year_in_posthog/2024.html
similarity index 99%
rename from posthog/year_in_posthog/2023.html
rename to posthog/year_in_posthog/2024.html
index 5604fb0c8fbcb..cb52db77ad278 100644
--- a/posthog/year_in_posthog/2023.html
+++ b/posthog/year_in_posthog/2024.html
@@ -24,7 +24,7 @@
         posthog.init('{{api_token}}', {
             api_host: window.location.origin, loaded: function (posthog) {
                 posthog.capture('year in posthog viewed', {
-                    'yearInPostHog': 2023, 'badge': '{{badge}}',     {% for stat in stats %}
+                    'yearInPostHog': 2024, 'badge': '{{badge}}',     {% for stat in stats %}
                         '{{ stat.description }}': {{ stat.count }},
                     {% endfor %}
                 });
diff --git a/posthog/year_in_posthog/calculate_2023.py b/posthog/year_in_posthog/calculate_2024.py
similarity index 92%
rename from posthog/year_in_posthog/calculate_2023.py
rename to posthog/year_in_posthog/calculate_2024.py
index 03428d2711d30..a260318cccb9c 100644
--- a/posthog/year_in_posthog/calculate_2023.py
+++ b/posthog/year_in_posthog/calculate_2024.py
@@ -18,7 +18,7 @@
         posthog_dashboarditem
     WHERE
         NOT created_by_id IS NULL
-        AND date_part('year', created_at) = 2023
+        AND date_part('year', created_at) = 2024
         AND (
             name IS NOT NULL
             OR derived_name IS NOT NULL
@@ -41,7 +41,7 @@
         key not ilike 'survey-targeting%%'
         AND key not ilike 'prompt-%%'
         AND key not ilike 'interview-%%'
-        AND date_part('year', created_at) = 2023
+        AND date_part('year', created_at) = 2024
         AND created_by_id = (select id from posthog_user where uuid = %(user_uuid)s)
     GROUP BY
         created_by_id
@@ -56,7 +56,7 @@
     FROM
         posthog_sessionrecordingviewed
     WHERE
-        date_part('year', created_at) = 2023
+        date_part('year', created_at) = 2024
         AND user_id = (select id from posthog_user where uuid = %(user_uuid)s)
     GROUP BY
         user_id
@@ -71,7 +71,7 @@
     FROM
         posthog_experiment
     WHERE
-        date_part('year', created_at) = 2023
+        date_part('year', created_at) = 2024
         AND created_by_id = (select id from posthog_user where uuid = %(user_uuid)s)
     GROUP BY
         created_by_id
@@ -86,7 +86,7 @@
     FROM
         posthog_dashboard
     WHERE
-        date_part('year', created_at) = 2023
+        date_part('year', created_at) = 2024
         AND created_by_id = (select id from posthog_user where uuid = %(user_uuid)s)
     GROUP BY
         created_by_id
@@ -102,7 +102,7 @@
         posthog_survey
     WHERE
         NOT created_by_id IS NULL
-        AND date_part('year', created_at) = 2023
+        AND date_part('year', created_at) = 2024
         AND created_by_id = (select id from posthog_user where uuid = %(user_uuid)s)
     group by
         created_by_id
@@ -111,7 +111,7 @@
     id,
     array_remove(
         ARRAY [
-        case when posthog_user.last_login >= '1-Jan-2023' then 'astronaut' end,
+        case when posthog_user.last_login >= '1-Jan-2024' then 'astronaut' end,
         insight_stats.badge,
         flag_stats.badge,
         recording_viewed_stats.badge,
@@ -147,7 +147,7 @@ def dictfetchall(cursor):
 
 
 @cache_for(timedelta(seconds=0 if settings.DEBUG else 30))
-def calculate_year_in_posthog_2023(user_uuid: str) -> Optional[dict]:
+def calculate_year_in_posthog_2024(user_uuid: str) -> Optional[dict]:
     with connection.cursor() as cursor:
         cursor.execute(query, {"user_uuid": user_uuid})
         rows = dictfetchall(cursor)
diff --git a/posthog/year_in_posthog/hibernating.html b/posthog/year_in_posthog/hibernating.html
index 873f10528be13..c7e57048087a9 100644
--- a/posthog/year_in_posthog/hibernating.html
+++ b/posthog/year_in_posthog/hibernating.html
@@ -24,7 +24,7 @@
         posthog.init('{{api_token}}', {
             api_host: window.location.origin, loaded: function (posthog) {
                 posthog.capture('year in posthog hibernating viewed', {
-                    'yearInPostHog': 2022
+                    'yearInPostHog': 2023
                 });
             }
         })
diff --git a/posthog/year_in_posthog/sharing-buttons.html b/posthog/year_in_posthog/sharing-buttons.html
index 269f25cb456b3..8cabf76a97c19 100644
--- a/posthog/year_in_posthog/sharing-buttons.html
+++ b/posthog/year_in_posthog/sharing-buttons.html
@@ -1,8 +1,8 @@
 <div>Share to</div>
 <div>
     <a target="_blank"
-       aria-label="share year in posthog 2023 to facebook"
-       data-attr="share-year-in-posthog-2023-to-facebook"
+       aria-label="share year in posthog 2024 to facebook"
+       data-attr="share-year-in-posthog-2024-to-facebook"
        href="http://www.facebook.com/sharer/sharer.php?u={{ page_url | urlencode }}&quote=No hedgehogs were harmed in the course of this year on @posthog">
         <svg viewBox="0 0 24 24">
             <path fill="white"
@@ -12,8 +12,8 @@
 </div>
 <div>
     <a target="_blank"
-       aria-label="share year in posthog 2023 to linked in"
-       data-attr="share-year-in-posthog-2023-to-linked-in"
+       aria-label="share year in posthog 2024 to linked in"
+       data-attr="share-year-in-posthog-2024-to-linked-in"
        href="https://www.linkedin.com/sharing/share-offsite/?url={{ page_url | urlencode }}">
         <svg viewBox="0 0 24 24">
             <path fill="white"
@@ -23,8 +23,8 @@
 </div>
 <div>
     <a target="_blank"
-       aria-label="share year in posthog 2023 to twitter"
-       data-attr="share-year-in-posthog-2023-to-twitter"
+       aria-label="share year in posthog 2024 to twitter"
+       data-attr="share-year-in-posthog-2024-to-twitter"
        href="https://twitter.com/intent/tweet?text={{ 'No hedgehogs were harmed in the course of this year on @posthog' }}&url={{ page_url | urlencode }}&hashtags=PostHogUnwrapped">
         <svg viewBox="0 0 24 24">
             <path fill="white"
@@ -32,3 +32,11 @@
         </svg>
     </a>
 </div>
+<div>
+    <a target="_blank"
+       aria-label="share year in posthog 2024 to bluesky"
+       data-attr="share-year-in-posthog-2024-to-bluesky"
+        href="https://bsky.app/intent/compose?text=No hedgehogs were harmed in the course of this year on PostHog. {{ page_url | urlencode }}. #PostHogUnwrapped">
+        <svg fill="none" viewBox="0 0 64 57"><path fill="white" d="M13.873 3.805C21.21 9.332 29.103 20.537 32 26.55v15.882c0-.338-.13.044-.41.867-1.512 4.456-7.418 21.847-20.923 7.944-7.111-7.32-3.819-14.64 9.125-16.85-7.405 1.264-15.73-.825-18.014-9.015C1.12 23.022 0 8.51 0 6.55 0-3.268 8.579-.182 13.873 3.805ZM50.127 3.805C42.79 9.332 34.897 20.537 32 26.55v15.882c0-.338.13.044.41.867 1.512 4.456 7.418 21.847 20.923 7.944 7.111-7.32 3.819-14.64-9.125-16.85 7.405 1.264 15.73-.825 18.014-9.015C62.88 23.022 64 8.51 64 6.55c0-9.818-8.578-6.732-13.873-2.745Z"></path></svg>
+    </a>
+</div>
diff --git a/posthog/year_in_posthog/year_in_posthog.py b/posthog/year_in_posthog/year_in_posthog.py
index a6ac65fa2fdaa..7e622f5bab5b5 100644
--- a/posthog/year_in_posthog/year_in_posthog.py
+++ b/posthog/year_in_posthog/year_in_posthog.py
@@ -9,7 +9,7 @@
 from sentry_sdk import capture_exception
 
 from posthog import settings
-from posthog.year_in_posthog.calculate_2023 import calculate_year_in_posthog_2023
+from posthog.year_in_posthog.calculate_2024 import calculate_year_in_posthog_2024
 
 logger = structlog.get_logger(__name__)
 
@@ -85,11 +85,11 @@ def sort_list_based_on_preference(badges: list[str]) -> str:
 
 
 @cache_control(public=True, max_age=300)  # cache for 5 minutes
-def render_2023(request, user_uuid: str) -> HttpResponse:
+def render_2024(request, user_uuid: str) -> HttpResponse:
     data = None
 
     try:
-        data = calculate_year_in_posthog_2023(user_uuid)
+        data = calculate_year_in_posthog_2024(user_uuid)
 
         badge = sort_list_based_on_preference(data.get("badges") or ["astronaut"])
         stats = stats_for_user(data)
@@ -124,12 +124,12 @@ def render_2023(request, user_uuid: str) -> HttpResponse:
             "page_url": f"{request.scheme}://{request.META['HTTP_HOST']}{request.get_full_path()}",
         }
 
-        template = get_template("2023.html")
+        template = get_template("2024.html")
         html = template.render(context, request=request)
         return HttpResponse(html)
     except Exception as e:
         capture_exception(e)
-        logger.error("year_in_posthog_2023_error_rendering_2023_page", exc_info=True, exc=e, data=data or "no data")
+        logger.error("year_in_posthog_2024_error_rendering_2024_page", exc_info=True, exc=e, data=data or "no data")
         template = get_template("hibernating.html")
         html = template.render({"message": "Something went wrong 🫠"}, request=request)
         return HttpResponse(html, status=500)
@@ -140,3 +140,10 @@ def render_2022(request, user_uuid: str) -> HttpResponse:
     template = get_template("hibernating.html")
     html = template.render({"message": "This is the 2022 Year in PostHog. That's too long ago 🙃"}, request=request)
     return HttpResponse(html)
+
+
+@cache_control(public=True, max_age=300)  # cache for 5 minutes
+def render_2023(request, user_uuid: str) -> HttpResponse:
+    template = get_template("hibernating.html")
+    html = template.render({"message": "This is the 2023 Year in PostHog. That's too long ago 🙃"}, request=request)
+    return HttpResponse(html)
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 41a109d8cb97f..cc0e410715cd7 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,6 +1,10 @@
 # This file was autogenerated by uv via the following command:
 #    uv pip compile requirements-dev.in -o requirements-dev.txt
-aiohttp==3.9.3
+aiohappyeyeballs==2.4.4
+    # via
+    #   -c requirements.txt
+    #   aiohttp
+aiohttp==3.11.10
     # via
     #   -c requirements.txt
     #   aioresponses
@@ -235,7 +239,7 @@ jsonschema-specifications==2023.12.1
     #   -c requirements.txt
     #   jsonschema
     #   openapi-schema-validator
-langchain==0.3.3
+langchain==0.3.9
     # via
     #   -c requirements.txt
     #   deepeval
@@ -243,7 +247,7 @@ langchain==0.3.3
     #   ragas
 langchain-community==0.3.2
     # via ragas
-langchain-core==0.3.10
+langchain-core==0.3.21
     # via
     #   -c requirements.txt
     #   deepeval
@@ -252,7 +256,7 @@ langchain-core==0.3.10
     #   langchain-openai
     #   langchain-text-splitters
     #   ragas
-langchain-openai==0.2.2
+langchain-openai==0.2.11
     # via
     #   -c requirements.txt
     #   deepeval
@@ -310,7 +314,7 @@ numpy==1.23.3
     #   pandas
     #   pyarrow
     #   ragas
-openai==1.51.2
+openai==1.56.2
     # via
     #   -c requirements.txt
     #   langchain-openai
@@ -378,6 +382,11 @@ pprintpp==0.4.0
     # via pytest-icdiff
 prance==23.6.21.0
     # via -r requirements-dev.in
+propcache==0.2.1
+    # via
+    #   -c requirements.txt
+    #   aiohttp
+    #   yarl
 protobuf==4.22.1
     # via
     #   -c requirements.txt
@@ -672,7 +681,7 @@ wrapt==1.15.0
     #   deprecated
 xxhash==3.5.0
     # via datasets
-yarl==1.9.4
+yarl==1.18.3
     # via
     #   -c requirements.txt
     #   aiohttp
diff --git a/requirements.in b/requirements.in
index 264da25775f89..16ee79fb66e03 100644
--- a/requirements.in
+++ b/requirements.in
@@ -4,7 +4,7 @@
 # - `uv pip compile requirements.in -o requirements.txt`
 # - `uv pip compile requirements-dev.in -o requirements-dev.txt`
 #
-aiohttp>=3.9.0
+aiohttp==3.11.10
 aioboto3==12.0.0
 aiokafka>=0.8
 antlr4-python3-runtime==4.13.1
@@ -45,11 +45,10 @@ infi-clickhouse-orm@ git+https://github.com/PostHog/infi.clickhouse_orm@9578c79f
 jsonref==1.1.0
 kafka-python==2.0.2
 kombu==5.3.2
-langchain==0.3.3
-langchain-openai==0.2.2
-langfuse==2.52.1
-langgraph==0.2.34
-langsmith==0.1.132
+langchain==0.3.9
+langchain-openai==0.2.11
+langfuse==2.55.0
+langgraph==0.2.56
 lzstring==1.0.4
 multidict==6.0.5 # Not used by us directly, but code won't run on Ubuntu 24.04 unless we resolve this to 6.0.5
 natsort==8.4.0
@@ -104,7 +103,7 @@ mimesis==5.2.1
 more-itertools==9.0.0
 django-two-factor-auth==1.14.0
 phonenumberslite==8.13.6
-openai==1.51.2
+openai==1.56.2
 tiktoken==0.8.0
 nh3==0.2.14
 hogql-parser==1.0.47
diff --git a/requirements.txt b/requirements.txt
index 3c09a5963c90e..cd9ac20220391 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,7 +6,9 @@ aiobotocore==2.7.0
     # via
     #   aioboto3
     #   s3fs
-aiohttp==3.9.3
+aiohappyeyeballs==2.4.4
+    # via aiohttp
+aiohttp==3.11.10
     # via
     #   -r requirements.in
     #   aiobotocore
@@ -292,6 +294,7 @@ httpcore==1.0.2
 httpx==0.26.0
     # via
     #   langfuse
+    #   langgraph-sdk
     #   langsmith
     #   openai
 humanize==4.9.0
@@ -344,28 +347,29 @@ kombu==5.3.2
     # via
     #   -r requirements.in
     #   celery
-langchain==0.3.3
+langchain==0.3.9
     # via -r requirements.in
-langchain-core==0.3.10
+langchain-core==0.3.21
     # via
     #   langchain
     #   langchain-openai
     #   langchain-text-splitters
     #   langgraph
     #   langgraph-checkpoint
-langchain-openai==0.2.2
+langchain-openai==0.2.11
     # via -r requirements.in
 langchain-text-splitters==0.3.0
     # via langchain
-langfuse==2.52.1
+langfuse==2.55.0
     # via -r requirements.in
-langgraph==0.2.34
+langgraph==0.2.56
     # via -r requirements.in
-langgraph-checkpoint==2.0.1
+langgraph-checkpoint==2.0.8
+    # via langgraph
+langgraph-sdk==0.1.43
     # via langgraph
 langsmith==0.1.132
     # via
-    #   -r requirements.in
     #   langchain
     #   langchain-core
 lxml==4.9.4
@@ -414,7 +418,7 @@ oauthlib==3.1.0
     # via
     #   requests-oauthlib
     #   social-auth-core
-openai==1.51.2
+openai==1.56.2
     # via
     #   -r requirements.in
     #   langchain-openai
@@ -425,6 +429,7 @@ orjson==3.10.7
     # via
     #   -r requirements.in
     #   dlt
+    #   langgraph-sdk
     #   langsmith
 outcome==1.3.0.post0
     # via trio
@@ -468,6 +473,10 @@ prometheus-client==0.14.1
     # via django-prometheus
 prompt-toolkit==3.0.39
     # via click-repl
+propcache==0.2.1
+    # via
+    #   aiohttp
+    #   yarl
 proto-plus==1.22.3
     # via google-cloud-bigquery-storage
 protobuf==4.22.1
@@ -592,6 +601,7 @@ requests==2.32.0
     #   google-cloud-bigquery
     #   infi-clickhouse-orm
     #   langchain
+    #   langfuse
     #   langsmith
     #   pdpyras
     #   posthoganalytics
@@ -800,7 +810,7 @@ xmlsec==1.3.13
     # via
     #   -r requirements.in
     #   python3-saml
-yarl==1.9.4
+yarl==1.18.3
     # via aiohttp
 zeep==4.2.1
     # via simple-salesforce
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 506c8d333363d..12ea18182d17e 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -1219,6 +1219,7 @@ dependencies = [
  "serde_json",
  "thiserror",
  "time",
+ "tokio",
  "tracing",
  "uuid",
 ]
diff --git a/rust/capture/src/config.rs b/rust/capture/src/config.rs
index c74bd9d395a75..5cb5cf006edde 100644
--- a/rust/capture/src/config.rs
+++ b/rust/capture/src/config.rs
@@ -41,6 +41,7 @@ pub struct Config {
     pub overflow_burst_limit: NonZeroU32,
 
     pub overflow_forced_keys: Option<String>, // Coma-delimited keys
+    pub dropped_keys: Option<String>, // "<token>:<distinct_id or *>,<distinct_id or *>;<token>..."
 
     #[envconfig(nested = true)]
     pub kafka: KafkaConfig,
diff --git a/rust/capture/src/limiters/mod.rs b/rust/capture/src/limiters/mod.rs
index b389f6e16e348..d31e3eb59dc48 100644
--- a/rust/capture/src/limiters/mod.rs
+++ b/rust/capture/src/limiters/mod.rs
@@ -1,2 +1,3 @@
 pub mod overflow;
 pub mod redis;
+pub mod token_dropper;
diff --git a/rust/capture/src/limiters/token_dropper.rs b/rust/capture/src/limiters/token_dropper.rs
new file mode 100644
index 0000000000000..0d6358443c619
--- /dev/null
+++ b/rust/capture/src/limiters/token_dropper.rs
@@ -0,0 +1,76 @@
+use std::collections::HashMap;
+
+use tracing::warn;
+
+#[derive(Default)]
+pub struct TokenDropper {
+    to_drop: HashMap<String, Vec<String>>,
+}
+
+impl TokenDropper {
+    // Takes "<token>:<distinct_id or *>,<distinct_id or *>;<token>..."
+    pub fn new(config: &str) -> Self {
+        let mut to_drop = HashMap::new();
+        for pair in config.split(';') {
+            let mut parts = pair.split(':');
+            let Some(token) = parts.next() else {
+                warn!("No distinct id's configured for pair {}", pair);
+                continue;
+            };
+            let Some(ids) = parts.next() else {
+                warn!("No distinct id's configured for token {}", token);
+                continue;
+            };
+            let ids = ids.split(',').map(|s| s.to_string()).collect();
+            to_drop.insert(token.to_string(), ids);
+        }
+        Self { to_drop }
+    }
+
+    pub fn should_drop(&self, token: &str, distinct_id: &str) -> bool {
+        self.to_drop
+            .get(token)
+            .map(|ids| ids.iter().any(|id| id == distinct_id || id == "*"))
+            .unwrap_or(false)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_empty_config() {
+        let dropper = TokenDropper::new("");
+        assert!(!dropper.should_drop("token", "id"));
+    }
+
+    #[test]
+    fn test_single_token_id() {
+        let dropper = TokenDropper::new("token:id");
+        assert!(dropper.should_drop("token", "id"));
+        assert!(!dropper.should_drop("token", "other"));
+    }
+
+    #[test]
+    fn test_multiple_ids() {
+        let dropper = TokenDropper::new("token:id1,id2");
+        assert!(dropper.should_drop("token", "id1"));
+        assert!(dropper.should_drop("token", "id2"));
+        assert!(!dropper.should_drop("token", "id3"));
+    }
+
+    #[test]
+    fn test_wildcard() {
+        let dropper = TokenDropper::new("token:*");
+        assert!(dropper.should_drop("token", "anything"));
+    }
+
+    #[test]
+    fn test_multiple_tokens() {
+        let dropper = TokenDropper::new("token1:id1;token2:id2");
+        assert!(dropper.should_drop("token1", "id1"));
+        assert!(dropper.should_drop("token2", "id2"));
+        assert!(!dropper.should_drop("token1", "id2"));
+    }
+}
diff --git a/rust/capture/src/router.rs b/rust/capture/src/router.rs
index 011bb49d67502..dfb176779222d 100644
--- a/rust/capture/src/router.rs
+++ b/rust/capture/src/router.rs
@@ -12,6 +12,7 @@ use tower::limit::ConcurrencyLimitLayer;
 use tower_http::cors::{AllowHeaders, AllowOrigin, CorsLayer};
 use tower_http::trace::TraceLayer;
 
+use crate::limiters::token_dropper::TokenDropper;
 use crate::test_endpoint;
 use crate::{limiters::redis::RedisLimiter, redis::Client, sinks, time::TimeSource, v0_endpoint};
 
@@ -28,6 +29,7 @@ pub struct State {
     pub timesource: Arc<dyn TimeSource + Send + Sync>,
     pub redis: Arc<dyn Client + Send + Sync>,
     pub billing_limiter: RedisLimiter,
+    pub token_dropper: Arc<TokenDropper>,
     pub event_size_limit: usize,
 }
 
@@ -46,6 +48,7 @@ pub fn router<
     sink: S,
     redis: Arc<R>,
     billing_limiter: RedisLimiter,
+    token_dropper: TokenDropper,
     metrics: bool,
     capture_mode: CaptureMode,
     concurrency_limit: Option<usize>,
@@ -57,6 +60,7 @@ pub fn router<
         redis,
         billing_limiter,
         event_size_limit,
+        token_dropper: Arc::new(token_dropper),
     };
 
     // Very permissive CORS policy, as old SDK versions
diff --git a/rust/capture/src/server.rs b/rust/capture/src/server.rs
index d20f75c3d3a38..d935e106cf3b6 100644
--- a/rust/capture/src/server.rs
+++ b/rust/capture/src/server.rs
@@ -13,6 +13,8 @@ use crate::limiters::overflow::OverflowLimiter;
 use crate::limiters::redis::{
     QuotaResource, RedisLimiter, OVERFLOW_LIMITER_CACHE_KEY, QUOTA_LIMITER_CACHE_KEY,
 };
+
+use crate::limiters::token_dropper::TokenDropper;
 use crate::redis::RedisClient;
 use crate::router;
 use crate::router::BATCH_BODY_SIZE;
@@ -54,6 +56,11 @@ where
     )
     .expect("failed to create billing limiter");
 
+    let token_dropper = config
+        .dropped_keys
+        .map(|k| TokenDropper::new(&k))
+        .unwrap_or_default();
+
     // In Recordings capture mode, we unpack a batch of events, and then pack them back up into
     // a big blob and send to kafka all at once - so we should abort unpacking a batch if the data
     // size crosses the kafka limit. In the Events mode, we can unpack the batch and send each
@@ -78,6 +85,7 @@ where
             PrintSink {},
             redis_client,
             billing_limiter,
+            token_dropper,
             config.export_prometheus,
             config.capture_mode,
             config.concurrency_limit,
@@ -126,6 +134,7 @@ where
             sink,
             redis_client,
             billing_limiter,
+            token_dropper,
             config.export_prometheus,
             config.capture_mode,
             config.concurrency_limit,
diff --git a/rust/capture/src/token.rs b/rust/capture/src/token.rs
index 7924cc9511485..3e7d99c333a7f 100644
--- a/rust/capture/src/token.rs
+++ b/rust/capture/src/token.rs
@@ -12,6 +12,7 @@ pub enum InvalidTokenReason {
     TooLong,
     NotAscii,
     PersonalApiKey,
+    NullByte,
 }
 
 impl InvalidTokenReason {
@@ -22,6 +23,7 @@ impl InvalidTokenReason {
             // Self::IsNotString => "not_string",
             Self::TooLong => "too_long",
             Self::PersonalApiKey => "personal_api_key",
+            Self::NullByte => "null_byte",
         }
     }
 }
@@ -57,6 +59,11 @@ pub fn validate_token(token: &str) -> Result<(), InvalidTokenReason> {
         return Err(InvalidTokenReason::PersonalApiKey);
     }
 
+    // We refuse tokens with null bytes
+    if token.contains('\0') {
+        return Err(InvalidTokenReason::NullByte);
+    }
+
     Ok(())
 }
 
@@ -96,4 +103,12 @@ mod tests {
         assert!(valid.is_err());
         assert_eq!(valid.unwrap_err(), InvalidTokenReason::PersonalApiKey);
     }
+
+    #[test]
+    fn blocks_null_byte() {
+        let valid = validate_token("hello\0there");
+
+        assert!(valid.is_err());
+        assert_eq!(valid.unwrap_err(), InvalidTokenReason::NullByte);
+    }
 }
diff --git a/rust/capture/src/v0_endpoint.rs b/rust/capture/src/v0_endpoint.rs
index e21e3a5c94520..c30981c6239c2 100644
--- a/rust/capture/src/v0_endpoint.rs
+++ b/rust/capture/src/v0_endpoint.rs
@@ -14,6 +14,7 @@ use serde_json::json;
 use serde_json::Value;
 use tracing::instrument;
 
+use crate::limiters::token_dropper::TokenDropper;
 use crate::prometheus::report_dropped_events;
 use crate::v0_request::{
     Compression, DataType, ProcessedEvent, ProcessedEventMetadata, ProcessingContext, RawRequest,
@@ -172,7 +173,14 @@ pub async fn event(
         }
         Err(err) => Err(err),
         Ok((context, events)) => {
-            if let Err(err) = process_events(state.sink.clone(), &events, &context).await {
+            if let Err(err) = process_events(
+                state.sink.clone(),
+                state.token_dropper.clone(),
+                &events,
+                &context,
+            )
+            .await
+            {
                 let cause = match err {
                     CaptureError::EmptyDistinctId => "empty_distinct_id",
                     CaptureError::MissingDistinctId => "missing_distinct_id",
@@ -300,14 +308,24 @@ pub fn process_single_event(
 #[instrument(skip_all, fields(events = events.len()))]
 pub async fn process_events<'a>(
     sink: Arc<dyn sinks::Event + Send + Sync>,
+    dropper: Arc<TokenDropper>,
     events: &'a [RawEvent],
     context: &'a ProcessingContext,
 ) -> Result<(), CaptureError> {
-    let events: Vec<ProcessedEvent> = events
+    let mut events: Vec<ProcessedEvent> = events
         .iter()
         .map(|e| process_single_event(e, context))
         .collect::<Result<Vec<ProcessedEvent>, CaptureError>>()?;
 
+    events.retain(|e| {
+        if dropper.should_drop(&e.event.token, &e.event.distinct_id) {
+            report_dropped_events("token_dropper", 1);
+            false
+        } else {
+            true
+        }
+    });
+
     tracing::debug!(events=?events, "processed {} events", events.len());
 
     if events.len() == 1 {
diff --git a/rust/capture/tests/common.rs b/rust/capture/tests/common.rs
index 02a0d2caa8a09..3660c16f6ab85 100644
--- a/rust/capture/tests/common.rs
+++ b/rust/capture/tests/common.rs
@@ -39,6 +39,7 @@ pub static DEFAULT_CONFIG: Lazy<Config> = Lazy::new(|| Config {
     overflow_burst_limit: NonZeroU32::new(5).unwrap(),
     overflow_per_second_limit: NonZeroU32::new(10).unwrap(),
     overflow_forced_keys: None,
+    dropped_keys: None,
     kafka: KafkaConfig {
         kafka_producer_linger_ms: 0, // Send messages as soon as possible
         kafka_producer_queue_mib: 10,
diff --git a/rust/capture/tests/django_compat.rs b/rust/capture/tests/django_compat.rs
index 67be98629cf11..c792f57173c61 100644
--- a/rust/capture/tests/django_compat.rs
+++ b/rust/capture/tests/django_compat.rs
@@ -7,6 +7,7 @@ use base64::Engine;
 use capture::api::{CaptureError, CaptureResponse, CaptureResponseCode};
 use capture::config::CaptureMode;
 use capture::limiters::redis::{QuotaResource, RedisLimiter, QUOTA_LIMITER_CACHE_KEY};
+use capture::limiters::token_dropper::TokenDropper;
 use capture::redis::MockRedisClient;
 use capture::router::router;
 use capture::sinks::Event;
@@ -117,6 +118,7 @@ async fn it_matches_django_capture_behaviour() -> anyhow::Result<()> {
             sink.clone(),
             redis,
             billing_limiter,
+            TokenDropper::default(),
             false,
             CaptureMode::Events,
             None,
diff --git a/rust/capture/tests/events.rs b/rust/capture/tests/events.rs
index e872d2ea9f171..763506839b62d 100644
--- a/rust/capture/tests/events.rs
+++ b/rust/capture/tests/events.rs
@@ -40,6 +40,62 @@ async fn it_captures_one_event() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn it_drops_events_if_dropper_enabled() -> Result<()> {
+    setup_tracing();
+    let token = random_string("token", 16);
+    let distinct_id = random_string("id", 16);
+    let dropped_id = random_string("id", 16);
+
+    let main_topic = EphemeralTopic::new().await;
+    let histo_topic = EphemeralTopic::new().await;
+    let mut config = DEFAULT_CONFIG.clone();
+    config.kafka.kafka_topic = main_topic.topic_name().to_string();
+    config.kafka.kafka_historical_topic = histo_topic.topic_name().to_string();
+    config.dropped_keys = Some(format!("{}:{}", token, dropped_id));
+    let server = ServerHandle::for_config(config).await;
+
+    let event = json!({
+        "token": token,
+        "event": "testing",
+        "distinct_id": distinct_id
+    });
+
+    let dropped = json!({
+        "token": token,
+        "event": "testing",
+        "distinct_id": dropped_id
+    });
+
+    let res = server.capture_events(event.to_string()).await;
+    assert_eq!(StatusCode::OK, res.status());
+    let res = server.capture_events(dropped.to_string()).await;
+    assert_eq!(StatusCode::OK, res.status());
+    let res = server.capture_events(event.to_string()).await;
+    assert_eq!(StatusCode::OK, res.status());
+
+    let event = main_topic.next_event()?;
+    assert_json_include!(
+        actual: event,
+        expected: json!({
+            "token": token,
+            "distinct_id": distinct_id
+        })
+    );
+
+    // Next event we get is identical to the first, because the dropped event is not captured
+    let event = main_topic.next_event()?;
+    assert_json_include!(
+        actual: event,
+        expected: json!({
+            "token": token,
+            "distinct_id": distinct_id
+        })
+    );
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn it_captures_a_posthogjs_array() -> Result<()> {
     setup_tracing();
diff --git a/rust/common/kafka/Cargo.toml b/rust/common/kafka/Cargo.toml
index 715e7bc04265a..b2bfddd0088c8 100644
--- a/rust/common/kafka/Cargo.toml
+++ b/rust/common/kafka/Cargo.toml
@@ -18,3 +18,4 @@ tracing = { workspace = true }
 uuid = { workspace = true }
 thiserror = { workspace = true }
 futures = { workspace = true }
+tokio = { workspace = true }
diff --git a/rust/common/kafka/src/kafka_consumer.rs b/rust/common/kafka/src/kafka_consumer.rs
index 0b55027f682d6..79c3be7f986d5 100644
--- a/rust/common/kafka/src/kafka_consumer.rs
+++ b/rust/common/kafka/src/kafka_consumer.rs
@@ -6,6 +6,7 @@ use rdkafka::{
     ClientConfig, Message,
 };
 use serde::de::DeserializeOwned;
+use std::time::Duration;
 
 use crate::config::{ConsumerConfig, KafkaConfig};
 
@@ -97,6 +98,33 @@ impl SingleTopicConsumer {
 
         Ok((payload, offset))
     }
+
+    pub async fn json_recv_batch<T>(
+        &self,
+        max: usize,
+        timeout: Duration,
+    ) -> Vec<Result<(T, Offset), RecvErr>>
+    where
+        T: DeserializeOwned,
+    {
+        let mut results = Vec::with_capacity(max);
+
+        tokio::select! {
+            _ = tokio::time::sleep(timeout) => {},
+            _ = async {
+                while results.len() < max {
+                    let result = self.json_recv::<T>().await;
+                    let was_err = result.is_err();
+                    results.push(result);
+                    if was_err {
+                        break; // Early exit on error, since it might indicate a kafka error or something
+                    }
+                }
+            } => {}
+        }
+
+        results
+    }
 }
 
 pub struct Offset {
diff --git a/rust/common/types/src/event.rs b/rust/common/types/src/event.rs
index 5ce5efb62e8cf..309f86c35543c 100644
--- a/rust/common/types/src/event.rs
+++ b/rust/common/types/src/event.rs
@@ -39,7 +39,7 @@ pub enum PersonMode {
 pub struct ClickHouseEvent {
     pub uuid: Uuid,
     pub team_id: i32,
-    pub project_id: i32,
+    pub project_id: i64,
     pub event: String,
     pub distinct_id: String,
     #[serde(skip_serializing_if = "Option::is_none")]
diff --git a/rust/cymbal/src/config.rs b/rust/cymbal/src/config.rs
index 23968d02d1c4a..2b0cdaf20a50a 100644
--- a/rust/cymbal/src/config.rs
+++ b/rust/cymbal/src/config.rs
@@ -86,6 +86,12 @@ pub struct Config {
     // Maximum number of lines of pre and post context to get per frame
     #[envconfig(default = "15")]
     pub context_line_count: usize,
+
+    #[envconfig(default = "1000")]
+    pub max_events_per_batch: usize,
+
+    #[envconfig(default = "10")]
+    pub max_event_batch_wait_seconds: u64,
 }
 
 impl Config {
diff --git a/rust/cymbal/src/hack/kafka.rs b/rust/cymbal/src/hack/kafka.rs
index c57f27d80b0bd..cb26faede2165 100644
--- a/rust/cymbal/src/hack/kafka.rs
+++ b/rust/cymbal/src/hack/kafka.rs
@@ -9,7 +9,10 @@ use rdkafka::{
 };
 use serde::{de::DeserializeOwned, Serialize};
 use serde_json::error::Error as SerdeError;
-use std::sync::{Arc, Weak};
+use std::{
+    sync::{Arc, Weak},
+    time::Duration,
+};
 use thiserror::Error;
 use tracing::{debug, error, info};
 
@@ -145,6 +148,33 @@ impl SingleTopicConsumer {
 
         Ok((payload, offset))
     }
+
+    pub async fn json_recv_batch<T>(
+        &self,
+        max: usize,
+        timeout: Duration,
+    ) -> Vec<Result<(T, Offset), RecvErr>>
+    where
+        T: DeserializeOwned,
+    {
+        let mut results = Vec::with_capacity(max);
+
+        tokio::select! {
+            _ = tokio::time::sleep(timeout) => {},
+            _ = async {
+                while results.len() < max {
+                    let result = self.json_recv::<T>().await;
+                    let was_err = result.is_err();
+                    results.push(result);
+                    if was_err {
+                        break; // Early exit on error, since it might indicate a kafka error or something
+                    }
+                }
+            } => {}
+        }
+
+        results
+    }
 }
 
 pub struct Offset {
diff --git a/rust/cymbal/src/main.rs b/rust/cymbal/src/main.rs
index aeef86329462f..2146c4f46ee6d 100644
--- a/rust/cymbal/src/main.rs
+++ b/rust/cymbal/src/main.rs
@@ -58,46 +58,64 @@ async fn main() {
 
     start_health_liveness_server(&config, context.clone());
 
+    let batch_wait_time = std::time::Duration::from_secs(config.max_event_batch_wait_seconds);
+    let batch_size = config.max_events_per_batch;
+
     loop {
         let whole_loop = common_metrics::timing_guard(MAIN_LOOP_TIME, &[]);
         context.worker_liveness.report_healthy().await;
         // Just grab the event as a serde_json::Value and immediately drop it,
         // we can work out a real type for it later (once we're deployed etc)
-        let (event, offset): (ClickHouseEvent, _) = match context.kafka_consumer.json_recv().await {
-            Ok(r) => r,
-            Err(RecvErr::Kafka(e)) => {
-                panic!("Kafka error: {}", e)
-            }
-            Err(err) => {
-                // If we failed to parse the message, or it was empty, just log and continue, our
-                // consumer has already stored the offset for us.
-                metrics::counter!(ERRORS, "cause" => "recv_err").increment(1);
-                error!("Error receiving message: {:?}", err);
-                continue;
-            }
-        };
-        metrics::counter!(EVENT_RECEIVED).increment(1);
-
-        let event = match handle_event(context.clone(), event).await {
-            Ok(e) => e,
-            Err(e) => {
-                error!("Error handling event: {:?}", e);
-                // If we get an unhandled error, it means we have some logical error in the code, or a
-                // dependency is down, and we should just fall over.
-                panic!("Unhandled error: {:?}", e);
-            }
-        };
+        let received: Vec<Result<(ClickHouseEvent, _), _>> = context
+            .kafka_consumer
+            .json_recv_batch(batch_size, batch_wait_time)
+            .await;
+
+        let mut output = Vec::with_capacity(received.len());
+        let mut offsets = Vec::with_capacity(received.len());
+        for message in received {
+            let (event, offset) = match message {
+                Ok(r) => r,
+                Err(RecvErr::Kafka(e)) => {
+                    panic!("Kafka error: {}", e)
+                }
+                Err(err) => {
+                    // If we failed to parse the message, or it was empty, just log and continue, our
+                    // consumer has already stored the offset for us.
+                    metrics::counter!(ERRORS, "cause" => "recv_err").increment(1);
+                    error!("Error receiving message: {:?}", err);
+                    continue;
+                }
+            };
+
+            metrics::counter!(EVENT_RECEIVED).increment(1);
+
+            let event = match handle_event(context.clone(), event).await {
+                Ok(e) => e,
+                Err(e) => {
+                    error!("Error handling event: {:?}", e);
+                    // If we get an unhandled error, it means we have some logical error in the code, or a
+                    // dependency is down, and we should just fall over.
+                    panic!("Unhandled error: {:?}", e);
+                }
+            };
+
+            output.push(event);
+            offsets.push(offset);
+        }
 
         send_keyed_iter_to_kafka(
             &context.kafka_producer,
             &context.config.events_topic,
             |ev| Some(ev.uuid.to_string()),
-            &[event],
+            &output,
         )
         .await
         .expect("Failed to send event to Kafka");
 
-        offset.store().unwrap();
+        for offset in offsets {
+            offset.store().unwrap();
+        }
 
         metrics::counter!(STACK_PROCESSED).increment(1);
         whole_loop.label("finished", "true").fin();
diff --git a/rust/cymbal/src/metric_consts.rs b/rust/cymbal/src/metric_consts.rs
index 797e47417f5d7..d0ec3cdab31b3 100644
--- a/rust/cymbal/src/metric_consts.rs
+++ b/rust/cymbal/src/metric_consts.rs
@@ -11,6 +11,7 @@ pub const STORE_CACHE_MISSES: &str = "cymbal_store_cache_misses";
 pub const STORE_CACHED_BYTES: &str = "cymbal_store_cached_bytes";
 pub const STORE_CACHE_SIZE: &str = "cymbal_store_cache_size";
 pub const STORE_CACHE_EVICTIONS: &str = "cymbal_store_cache_evictions";
+pub const STORE_CACHE_EVICTION_RUNS: &str = "cymbal_store_cache_eviction_runs";
 pub const MAIN_LOOP_TIME: &str = "cymbal_main_loop_time";
 pub const PER_FRAME_TIME: &str = "cymbal_per_frame_time";
 pub const PER_STACK_TIME: &str = "cymbal_per_stack_time";
diff --git a/rust/cymbal/src/symbol_store/caching.rs b/rust/cymbal/src/symbol_store/caching.rs
index 5cab851fdaca7..1f1cb22ac9f0b 100644
--- a/rust/cymbal/src/symbol_store/caching.rs
+++ b/rust/cymbal/src/symbol_store/caching.rs
@@ -6,7 +6,8 @@ use tokio::sync::Mutex;
 use crate::{
     error::Error,
     metric_consts::{
-        STORE_CACHED_BYTES, STORE_CACHE_EVICTIONS, STORE_CACHE_HITS, STORE_CACHE_MISSES,
+        STORE_CACHED_BYTES, STORE_CACHE_EVICTIONS, STORE_CACHE_EVICTION_RUNS, STORE_CACHE_HITS,
+        STORE_CACHE_MISSES,
     },
 };
 
@@ -117,7 +118,7 @@ impl SymbolSetCache {
             return;
         }
 
-        metrics::counter!(STORE_CACHE_EVICTIONS).increment(1);
+        metrics::counter!(STORE_CACHE_EVICTION_RUNS).increment(1);
 
         let mut vals: Vec<_> = self.cached.iter().collect();
 
@@ -137,6 +138,11 @@ impl SymbolSetCache {
             to_remove.push(to_remove_key.clone());
         }
 
+        for key in to_remove {
+            metrics::counter!(STORE_CACHE_EVICTIONS).increment(1);
+            self.cached.remove(&key);
+        }
+
         metrics::gauge!(STORE_CACHED_BYTES).set(self.held_bytes as f64);
     }
 }
diff --git a/rust/feature-flags/src/api/endpoint.rs b/rust/feature-flags/src/api/endpoint.rs
index e995cfd5dc15e..b083ee573c9e2 100644
--- a/rust/feature-flags/src/api/endpoint.rs
+++ b/rust/feature-flags/src/api/endpoint.rs
@@ -46,7 +46,6 @@ pub async fn flags(
     let context = RequestContext {
         state,
         ip,
-        meta: meta.0,
         headers,
         body,
     };
diff --git a/rust/feature-flags/src/api/handler.rs b/rust/feature-flags/src/api/handler.rs
index 0fdade8d95128..7a6bef7eed098 100644
--- a/rust/feature-flags/src/api/handler.rs
+++ b/rust/feature-flags/src/api/handler.rs
@@ -58,7 +58,6 @@ pub struct FlagsQueryParams {
 pub struct RequestContext {
     pub state: State<router::State>,
     pub ip: IpAddr,
-    pub meta: FlagsQueryParams,
     pub headers: HeaderMap,
     pub body: Bytes,
 }
@@ -82,11 +81,24 @@ pub struct FeatureFlagEvaluationContext {
     hash_key_override: Option<String>,
 }
 
+/// Process a feature flag request and return the evaluated flags
+///
+/// ## Flow
+/// 1. Decodes and validates the request
+/// 2. Extracts and verifies the authentication token
+/// 3. Retrieves team information
+/// 4. Processes person and group properties
+/// 5. Retrieves feature flags
+/// 6. Evaluates flags based on the context
+///
+/// ## Error Handling
+/// - Returns early if any step fails
+/// - Maintains error context through the FlagError enum
+/// - Individual flag evaluation failures don't fail the entire request
 pub async fn process_request(context: RequestContext) -> Result<FlagsResponse, FlagError> {
     let RequestContext {
         state,
         ip,
-        meta: _, // TODO use this
         headers,
         body,
     } = context;
@@ -95,12 +107,12 @@ pub async fn process_request(context: RequestContext) -> Result<FlagsResponse, F
     let token = request
         .extract_and_verify_token(state.redis.clone(), state.reader.clone())
         .await?;
+
     let team = request
         .get_team_from_cache_or_pg(&token, state.redis.clone(), state.reader.clone())
         .await?;
 
     let distinct_id = request.extract_distinct_id()?;
-    let groups = request.groups.clone();
     let team_id = team.id;
     let person_property_overrides = get_person_property_overrides(
         !request.geoip_disable.unwrap_or(false),
@@ -108,7 +120,11 @@ pub async fn process_request(context: RequestContext) -> Result<FlagsResponse, F
         &ip,
         &state.geoip,
     );
-    let group_property_overrides = request.group_properties.clone();
+
+    let groups = request.groups.clone();
+    let group_property_overrides =
+        process_group_property_overrides(groups.clone(), request.group_properties.clone());
+
     let hash_key_override = request.anon_distinct_id.clone();
 
     let feature_flags_from_cache_or_pg = request
@@ -170,6 +186,39 @@ pub fn get_person_property_overrides(
     }
 }
 
+/// Processes group property overrides by combining existing overrides with group key overrides
+///
+/// When groups are provided in the format {"group_type": "group_key"}, we need to ensure these
+/// are included in the group property overrides with the special "$group_key" property.
+fn process_group_property_overrides(
+    groups: Option<HashMap<String, Value>>,
+    existing_overrides: Option<HashMap<String, HashMap<String, Value>>>,
+) -> Option<HashMap<String, HashMap<String, Value>>> {
+    match groups {
+        Some(groups) => {
+            let group_key_overrides: HashMap<String, HashMap<String, Value>> = groups
+                .into_iter()
+                .map(|(group_type, group_key)| {
+                    let mut properties = existing_overrides
+                        .as_ref()
+                        .and_then(|g| g.get(&group_type))
+                        .cloned()
+                        .unwrap_or_default();
+
+                    properties.insert("$group_key".to_string(), group_key);
+
+                    (group_type, properties)
+                })
+                .collect();
+
+            let mut result = existing_overrides.unwrap_or_default();
+            result.extend(group_key_overrides);
+            Some(result)
+        }
+        None => existing_overrides,
+    }
+}
+
 /// Decode a request into a `FlagRequest`
 /// - Currently only supports JSON requests
 // TODO support all supported content types
@@ -738,4 +787,61 @@ mod tests {
         assert!(!result.error_while_computing_flags);
         assert_eq!(result.feature_flags["test_flag"], FlagValue::Boolean(true));
     }
+
+    #[test]
+    fn test_process_group_property_overrides() {
+        // Test case 1: Both groups and existing overrides
+        let groups = HashMap::from([
+            ("project".to_string(), json!("project_123")),
+            ("organization".to_string(), json!("org_456")),
+        ]);
+
+        let mut existing_overrides = HashMap::new();
+        let mut project_props = HashMap::new();
+        project_props.insert("industry".to_string(), json!("tech"));
+        existing_overrides.insert("project".to_string(), project_props);
+
+        let result =
+            process_group_property_overrides(Some(groups.clone()), Some(existing_overrides));
+
+        assert!(result.is_some());
+        let result = result.unwrap();
+
+        // Check project properties
+        let project_props = result.get("project").expect("Project properties missing");
+        assert_eq!(project_props.get("industry"), Some(&json!("tech")));
+        assert_eq!(project_props.get("$group_key"), Some(&json!("project_123")));
+
+        // Check organization properties
+        let org_props = result
+            .get("organization")
+            .expect("Organization properties missing");
+        assert_eq!(org_props.get("$group_key"), Some(&json!("org_456")));
+
+        // Test case 2: Only groups, no existing overrides
+        let result = process_group_property_overrides(Some(groups.clone()), None);
+
+        assert!(result.is_some());
+        let result = result.unwrap();
+        assert_eq!(result.len(), 2);
+        assert_eq!(
+            result.get("project").unwrap().get("$group_key"),
+            Some(&json!("project_123"))
+        );
+
+        // Test case 3: No groups, only existing overrides
+        let mut existing_overrides = HashMap::new();
+        let mut project_props = HashMap::new();
+        project_props.insert("industry".to_string(), json!("tech"));
+        existing_overrides.insert("project".to_string(), project_props);
+
+        let result = process_group_property_overrides(None, Some(existing_overrides.clone()));
+
+        assert!(result.is_some());
+        assert_eq!(result.unwrap(), existing_overrides);
+
+        // Test case 4: Neither groups nor existing overrides
+        let result = process_group_property_overrides(None, None);
+        assert!(result.is_none());
+    }
 }
diff --git a/rust/feature-flags/src/api/types.rs b/rust/feature-flags/src/api/types.rs
index 3eb81b7d1adad..0f04f2a5b40a5 100644
--- a/rust/feature-flags/src/api/types.rs
+++ b/rust/feature-flags/src/api/types.rs
@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use std::collections::HashMap;
 
 #[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
@@ -18,4 +19,5 @@ pub enum FlagValue {
 pub struct FlagsResponse {
     pub error_while_computing_flags: bool,
     pub feature_flags: HashMap<String, FlagValue>,
+    pub feature_flag_payloads: HashMap<String, Value>, // flag key -> payload
 }
diff --git a/rust/feature-flags/src/cohort/cohort_operations.rs b/rust/feature-flags/src/cohort/cohort_operations.rs
index 60afc7ca30f1c..b992e8f66473f 100644
--- a/rust/feature-flags/src/cohort/cohort_operations.rs
+++ b/rust/feature-flags/src/cohort/cohort_operations.rs
@@ -302,8 +302,6 @@ mod tests {
             .find(|c| c.id == main_cohort.id)
             .expect("Failed to find main cohort");
 
-        println!("fetched_main_cohort: {:?}", fetched_main_cohort);
-
         let dependencies = fetched_main_cohort.extract_dependencies().unwrap();
         let expected_dependencies: HashSet<CohortId> =
             [dependent_cohort.id].iter().cloned().collect();
diff --git a/rust/feature-flags/src/flags/flag_matching.rs b/rust/feature-flags/src/flags/flag_matching.rs
index 04b9dc67c7939..09287fde4fef0 100644
--- a/rust/feature-flags/src/flags/flag_matching.rs
+++ b/rust/feature-flags/src/flags/flag_matching.rs
@@ -308,9 +308,25 @@ impl FeatureFlagMatcher {
             error_while_computing_flags: initial_error
                 || flags_response.error_while_computing_flags,
             feature_flags: flags_response.feature_flags,
+            feature_flag_payloads: flags_response.feature_flag_payloads,
         }
     }
 
+    /// Processes hash key overrides for feature flags with experience continuity enabled.
+    ///
+    /// This method handles the logic for managing hash key overrides, which are used to ensure
+    /// consistent feature flag experiences across different distinct IDs (e.g., when a user logs in).
+    /// It performs the following steps:
+    ///
+    /// 1. Checks if a hash key override needs to be written by comparing the current distinct ID
+    ///    with the provided hash key
+    /// 2. If needed, writes the hash key override to the database using the writer connection
+    /// 3. Increments metrics to track successful/failed hash key override writes
+    /// 4. Retrieves and returns the current hash key overrides for the target distinct IDs
+    ///
+    /// Returns a tuple containing:
+    /// - Option<HashMap<String, String>>: The hash key overrides if successfully retrieved, None if there was an error
+    /// - bool: Whether there was an error during processing (true = error occurred)
     async fn process_hash_key_override(
         &self,
         hash_key: String,
@@ -397,15 +413,22 @@ impl FeatureFlagMatcher {
         }
     }
 
-    async fn evaluate_flags_with_overrides(
+    /// Evaluates feature flags with property and hash key overrides.
+    ///
+    /// This function evaluates feature flags in two steps:
+    /// 1. First, it evaluates flags that can be computed using only the provided property overrides
+    /// 2. Then, for remaining flags that need database properties, it fetches and caches those properties
+    ///    before evaluating those flags
+    pub async fn evaluate_flags_with_overrides(
         &mut self,
         feature_flags: FeatureFlagList,
         person_property_overrides: Option<HashMap<String, Value>>,
         group_property_overrides: Option<HashMap<String, HashMap<String, Value>>>,
         hash_key_overrides: Option<HashMap<String, String>>,
     ) -> FlagsResponse {
-        let mut result = HashMap::new();
         let mut error_while_computing_flags = false;
+        let mut feature_flags_map = HashMap::new();
+        let mut feature_flag_payloads_map = HashMap::new();
         let mut flags_needing_db_properties = Vec::new();
 
         // Step 1: Evaluate flags with locally computable property overrides first
@@ -425,7 +448,11 @@ impl FeatureFlagMatcher {
             {
                 Ok(Some(flag_match)) => {
                     let flag_value = self.flag_match_to_value(&flag_match);
-                    result.insert(flag.key.clone(), flag_value);
+                    feature_flags_map.insert(flag.key.clone(), flag_value);
+
+                    if let Some(payload) = flag_match.payload {
+                        feature_flag_payloads_map.insert(flag.key.clone(), payload);
+                    }
                 }
                 Ok(None) => {
                     flags_needing_db_properties.push(flag.clone());
@@ -448,21 +475,51 @@ impl FeatureFlagMatcher {
 
         // Step 2: Fetch and cache properties for remaining flags (just one DB lookup for all of relevant properties)
         if !flags_needing_db_properties.is_empty() {
-            let group_type_indexes: HashSet<GroupTypeIndex> = flags_needing_db_properties
+            let group_type_indexes_required: HashSet<GroupTypeIndex> = flags_needing_db_properties
                 .iter()
                 .filter_map(|flag| flag.get_group_type_index())
                 .collect();
 
+            // Map group names to group_type_index and group_keys
+            let group_type_to_key_map: HashMap<GroupTypeIndex, String> = self
+                .groups
+                .iter()
+                .filter_map(|(group_type, group_key_value)| {
+                    let group_key = group_key_value.as_str()?.to_string();
+                    self.group_type_mapping_cache
+                        .group_types_to_indexes
+                        .get(group_type)
+                        .cloned()
+                        .map(|group_type_index| (group_type_index, group_key))
+                })
+                .collect();
+
+            // Extract group_keys that are relevant to the required group_type_indexes
+            let group_keys: HashSet<String> = group_type_to_key_map
+                .iter()
+                .filter_map(|(group_type_index, group_key)| {
+                    if group_type_indexes_required.contains(group_type_index) {
+                        Some(group_key.clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            // Extract group_type_indexes for the required flags
+            let group_type_indexes: HashSet<GroupTypeIndex> = group_type_indexes_required.clone();
+
             let reader = self.reader.clone();
             let distinct_id = self.distinct_id.clone();
             let team_id = self.team_id;
 
-            match fetch_and_locally_cache_all_properties(
+            match fetch_and_locally_cache_all_relevant_properties(
                 &mut self.properties_cache,
                 reader,
                 distinct_id,
                 team_id,
                 &group_type_indexes,
+                &group_keys,
             )
             .await
             {
@@ -487,9 +544,6 @@ impl FeatureFlagMatcher {
             }
 
             // Step 3: Evaluate remaining flags with cached properties
-            // At this point we've already done a round of flag evaluations with locally computable property overrides
-            // This step is for flags that couldn't be evaluated locally due to missing property values,
-            // so we do a single query to fetch all of the remaining properties, and then proceed with flag evaluations
             for flag in flags_needing_db_properties {
                 match self
                     .get_match(&flag, None, hash_key_overrides.clone())
@@ -497,7 +551,11 @@ impl FeatureFlagMatcher {
                 {
                     Ok(flag_match) => {
                         let flag_value = self.flag_match_to_value(&flag_match);
-                        result.insert(flag.key.clone(), flag_value);
+                        feature_flags_map.insert(flag.key.clone(), flag_value);
+
+                        if let Some(payload) = flag_match.payload {
+                            feature_flag_payloads_map.insert(flag.key.clone(), payload);
+                        }
                     }
                     Err(e) => {
                         error_while_computing_flags = true;
@@ -519,7 +577,8 @@ impl FeatureFlagMatcher {
 
         FlagsResponse {
             error_while_computing_flags,
-            feature_flags: result,
+            feature_flags: feature_flags_map,
+            feature_flag_payloads: feature_flag_payloads_map,
         }
     }
 
@@ -638,6 +697,10 @@ impl FeatureFlagMatcher {
         property_overrides: Option<HashMap<String, Value>>,
         hash_key_overrides: Option<HashMap<String, String>>,
     ) -> Result<FeatureFlagMatch, FlagError> {
+        let ha = self
+            .hashed_identifier(flag, hash_key_overrides.clone())
+            .await?;
+        println!("hashed_identifier: {:?}", ha);
         if self
             .hashed_identifier(flag, hash_key_overrides.clone())
             .await?
@@ -1061,8 +1124,49 @@ impl FeatureFlagMatcher {
 
         let reader = self.reader.clone();
         let team_id = self.team_id;
+        // groups looks like this {"project": "project_123"}
+        // and then the group type index looks like this {"project": 1}
+        // so I want my group keys to look like this ["project_123"],
+        // but they need to be aware of the different group types
+        // Retrieve group_type_name using group_type_index from the cache
+        let group_type_mapping = self
+            .group_type_mapping_cache
+            .group_type_index_to_group_type_map()
+            .await?;
+        let group_type_name = match group_type_mapping.get(&group_type_index) {
+            Some(name) => name.clone(),
+            None => {
+                error!(
+                    "No group_type_name found for group_type_index {}",
+                    group_type_index
+                );
+                return Err(FlagError::NoGroupTypeMappings);
+            }
+        };
+
+        // Retrieve the corresponding group_key from self.groups using group_type_name
+        let group_key = match self.groups.get(&group_type_name) {
+            Some(Value::String(key)) => key.clone(),
+            Some(_) => {
+                error!(
+                    "Group key for group_type_name '{}' is not a string",
+                    group_type_name
+                );
+                return Err(FlagError::NoGroupTypeMappings);
+            }
+            None => {
+                // If there's no group_key provided for this group_type_name, we consider that there are no properties to fetch
+                return Ok(HashMap::new());
+            }
+        };
         let db_properties =
-            fetch_group_properties_from_db(reader, team_id, group_type_index).await?;
+            fetch_group_properties_from_db(reader, team_id, group_type_index, group_key).await?;
+
+        inc(
+            DB_GROUP_PROPERTIES_READS_COUNTER,
+            &[("team_id".to_string(), team_id.to_string())],
+            1,
+        );
 
         inc(
             DB_GROUP_PROPERTIES_READS_COUNTER,
@@ -1140,10 +1244,13 @@ impl FeatureFlagMatcher {
                 .await?
                 .get(&group_type_index)
                 .and_then(|group_type_name| self.groups.get(group_type_name))
-                .cloned()
-                .unwrap_or_default();
+                .and_then(|v| v.as_str())
+                // NB: we currently use empty string ("") as the hashed identifier for group flags without a group key,
+                // and I don't want to break parity with the old service since I don't want the hash values to change
+                .unwrap_or("")
+                .to_string();
 
-            Ok(group_key.to_string())
+            Ok(group_key)
         } else {
             // Person-based flag
             // Use hash key overrides for experience continuity
@@ -1172,9 +1279,9 @@ impl FeatureFlagMatcher {
             .hashed_identifier(feature_flag, hash_key_overrides)
             .await?;
         if hashed_identifier.is_empty() {
-            // Return a hash value that will make the flag evaluate to false
-            // TODO make this cleaner – we should have a way to return a default value
-            return Ok(0.0);
+            // Return a hash value that will make the flag evaluate to false; since we
+            // can't evaluate a flag without an identifier.
+            return Ok(0.0); // NB: A flag with 0.0 hash will always evaluate to false
         }
         let hash_key = format!("{}.{}{}", feature_flag.key, hashed_identifier, salt);
         let mut hasher = Sha1::new();
@@ -1248,7 +1355,7 @@ impl FeatureFlagMatcher {
 /// Evaluate static cohort filters by checking if the person is in each cohort.
 async fn evaluate_static_cohorts(
     reader: PostgresReader,
-    person_id: i32, // Change this parameter from distinct_id to person_id
+    person_id: i32,
     cohort_ids: Vec<CohortId>,
 ) -> Result<Vec<(CohortId, bool)>, FlagError> {
     let mut conn = reader.get_connection().await?;
@@ -1268,7 +1375,7 @@ async fn evaluate_static_cohorts(
 
     let rows = sqlx::query(query)
         .bind(&cohort_ids)
-        .bind(person_id) // Bind person_id directly
+        .bind(person_id)
         .fetch_all(&mut *conn)
         .await?;
 
@@ -1448,7 +1555,6 @@ fn build_cohort_dependency_graph(
         }
     }
 
-    // Check for cycles, this is an directed acyclic graph so we use is_cyclic_directed
     if is_cyclic_directed(&graph) {
         return Err(FlagError::CohortDependencyCycle(format!(
             "Cyclic dependency detected starting at cohort {}",
@@ -1463,52 +1569,62 @@ fn build_cohort_dependency_graph(
 ///
 /// This function fetches both person and group properties for a specified distinct ID and team ID.
 /// It updates the properties cache with the fetched properties and returns the result.
-async fn fetch_and_locally_cache_all_properties(
+async fn fetch_and_locally_cache_all_relevant_properties(
     properties_cache: &mut PropertiesCache,
     reader: PostgresReader,
     distinct_id: String,
     team_id: TeamId,
     group_type_indexes: &HashSet<GroupTypeIndex>,
+    group_keys: &HashSet<String>,
 ) -> Result<(), FlagError> {
     let mut conn = reader.as_ref().get_connection().await?;
 
     let query = r#"
-        SELECT 
-            person.person_id,
-            person.person_properties,
-            group_properties.group_properties
-        FROM (
-            SELECT 
-                "posthog_person"."id" AS person_id,
-                "posthog_person"."properties" AS person_properties
-            FROM "posthog_person"
-            INNER JOIN "posthog_persondistinctid" 
-                ON "posthog_person"."id" = "posthog_persondistinctid"."person_id"
-            WHERE 
-                "posthog_persondistinctid"."distinct_id" = $1
-                AND "posthog_persondistinctid"."team_id" = $2
-                AND "posthog_person"."team_id" = $2
-            LIMIT 1
-        ) AS person,
-        (
-            SELECT 
-                json_object_agg(
-                    "posthog_group"."group_type_index", 
-                    "posthog_group"."group_properties"
-                ) AS group_properties
-            FROM "posthog_group"
-            WHERE 
-                "posthog_group"."team_id" = $2
-                AND "posthog_group"."group_type_index" = ANY($3)
-        ) AS group_properties
+        SELECT
+            (
+                SELECT "posthog_person"."id"
+                FROM "posthog_person"
+                INNER JOIN "posthog_persondistinctid"
+                    ON "posthog_person"."id" = "posthog_persondistinctid"."person_id"
+                WHERE
+                    "posthog_persondistinctid"."distinct_id" = $1
+                    AND "posthog_persondistinctid"."team_id" = $2
+                    AND "posthog_person"."team_id" = $2
+                LIMIT 1
+            ) AS person_id,
+            (
+                SELECT "posthog_person"."properties"
+                FROM "posthog_person"
+                INNER JOIN "posthog_persondistinctid"
+                    ON "posthog_person"."id" = "posthog_persondistinctid"."person_id"
+                WHERE
+                    "posthog_persondistinctid"."distinct_id" = $1
+                    AND "posthog_persondistinctid"."team_id" = $2
+                    AND "posthog_person"."team_id" = $2
+                LIMIT 1
+            ) AS person_properties,
+            (
+                SELECT
+                    json_object_agg(
+                        "posthog_group"."group_type_index",
+                        "posthog_group"."group_properties"
+                    )
+                FROM "posthog_group"
+                WHERE
+                    "posthog_group"."team_id" = $2
+                    AND "posthog_group"."group_type_index" = ANY($3)
+                    AND "posthog_group"."group_key" = ANY($4)
+            ) AS group_properties
     "#;
 
     let group_type_indexes_vec: Vec<GroupTypeIndex> = group_type_indexes.iter().cloned().collect();
+    let group_keys_vec: Vec<String> = group_keys.iter().cloned().collect();
 
     let row: (Option<i32>, Option<Value>, Option<Value>) = sqlx::query_as(query)
         .bind(&distinct_id)
         .bind(team_id)
         .bind(&group_type_indexes_vec)
+        .bind(&group_keys_vec) // Bind group_keys_vec to $4
         .fetch_optional(&mut *conn)
         .await?
         .unwrap_or((None, None, None));
@@ -1602,6 +1718,7 @@ async fn fetch_group_properties_from_db(
     reader: PostgresReader,
     team_id: TeamId,
     group_type_index: GroupTypeIndex,
+    group_key: String,
 ) -> Result<HashMap<String, Value>, FlagError> {
     let mut conn = reader.as_ref().get_connection().await?;
 
@@ -1609,13 +1726,15 @@ async fn fetch_group_properties_from_db(
         SELECT "posthog_group"."group_properties"
         FROM "posthog_group"
         WHERE ("posthog_group"."team_id" = $1
-                AND "posthog_group"."group_type_index" = $2)
+                AND "posthog_group"."group_type_index" = $2
+                AND "posthog_group"."group_key" = $3)
         LIMIT 1
     "#;
 
     let row: Option<Value> = sqlx::query_scalar(query)
         .bind(team_id)
         .bind(group_type_index)
+        .bind(group_key)
         .fetch_optional(&mut *conn)
         .await?;
 
diff --git a/rust/feature-flags/src/utils/test_utils.rs b/rust/feature-flags/src/utils/test_utils.rs
index 1c6cf2b1caafe..99501fcaa8b78 100644
--- a/rust/feature-flags/src/utils/test_utils.rs
+++ b/rust/feature-flags/src/utils/test_utils.rs
@@ -261,6 +261,29 @@ pub async fn insert_new_team_in_pg(
     Ok(team)
 }
 
+pub async fn insert_group_type_mapping_in_pg(
+    client: Arc<dyn Client + Send + Sync>,
+    team_id: i32,
+    group_type: &str,
+    group_type_index: i32,
+) -> Result<(), Error> {
+    let mut conn = client.get_connection().await?;
+    let res = sqlx::query(
+        r#"INSERT INTO posthog_grouptypemapping
+           (team_id, project_id, group_type, group_type_index, name_singular, name_plural)
+           VALUES
+           ($1, $1, $2, $3, NULL, NULL)
+           ON CONFLICT (team_id, group_type) DO NOTHING"#,
+    )
+    .bind(team_id)
+    .bind(group_type)
+    .bind(group_type_index)
+    .execute(&mut *conn)
+    .await?;
+    assert_eq!(res.rows_affected(), 1);
+    Ok(())
+}
+
 pub async fn insert_flag_for_team_in_pg(
     client: Arc<dyn Client + Send + Sync>,
     team_id: i32,
@@ -454,3 +477,55 @@ pub async fn add_person_to_cohort(
 
     Ok(())
 }
+
+#[derive(Debug)]
+pub struct Group {
+    pub id: i32,
+    pub team_id: i32,
+    pub group_type_index: i32,
+    pub group_key: String,
+    pub group_properties: Value,
+}
+
+pub async fn create_group_in_pg(
+    client: Arc<dyn Client + Send + Sync>,
+    team_id: i32,
+    group_type: &str,
+    group_key: &str,
+    group_properties: Value,
+) -> Result<Group, Error> {
+    // First, retrieve the group_type_index from grouptypemapping
+    let mut conn = client.get_connection().await?;
+    let row = sqlx::query(
+        r#"SELECT group_type_index FROM posthog_grouptypemapping
+           WHERE team_id = $1 AND group_type = $2"#,
+    )
+    .bind(team_id)
+    .bind(group_type)
+    .fetch_one(&mut *conn)
+    .await?;
+    let group_type_index: i32 = row.get("group_type_index");
+
+    // Insert the group with all non-nullable fields
+    let res = sqlx::query(
+        r#"INSERT INTO posthog_group
+           (team_id, group_type_index, group_key, group_properties, created_at, properties_last_updated_at, properties_last_operation, version)
+           VALUES ($1, $2, $3, $4, '2024-06-17', '{}'::jsonb, '{}'::jsonb, 0)
+           RETURNING id"#,
+    )
+    .bind(team_id)
+    .bind(group_type_index)
+    .bind(group_key)
+    .bind(group_properties.clone())
+    .fetch_one(&mut *conn)
+    .await?;
+    let group_id: i32 = res.get("id");
+
+    Ok(Group {
+        id: group_id,
+        team_id,
+        group_type_index,
+        group_key: group_key.to_string(),
+        group_properties,
+    })
+}
diff --git a/rust/feature-flags/tests/test_flags.rs b/rust/feature-flags/tests/test_flags.rs
index 918a73ede6faa..9ee793596c0b1 100644
--- a/rust/feature-flags/tests/test_flags.rs
+++ b/rust/feature-flags/tests/test_flags.rs
@@ -1,6 +1,7 @@
 use anyhow::Result;
 use assert_json_diff::assert_json_include;
 
+use rand::Rng;
 use reqwest::StatusCode;
 use serde_json::{json, Value};
 
@@ -8,8 +9,9 @@ use crate::common::*;
 
 use feature_flags::config::DEFAULT_TEST_CONFIG;
 use feature_flags::utils::test_utils::{
-    insert_flags_for_team_in_redis, insert_new_team_in_pg, insert_new_team_in_redis,
-    setup_pg_reader_client, setup_redis_client,
+    create_group_in_pg, insert_flags_for_team_in_redis, insert_new_team_in_pg,
+    insert_new_team_in_redis, insert_person_for_team_in_pg, setup_pg_reader_client,
+    setup_redis_client,
 };
 
 pub mod common;
@@ -91,7 +93,7 @@ async fn it_rejects_invalid_headers_flag_request() -> Result<()> {
         .await;
     assert_eq!(StatusCode::BAD_REQUEST, res.status());
 
-    // We don't want to deserialize the data into a flagResponse struct here,
+    // We don't want to deserialize the data into a FlagsResponse struct here,
     // because we want to assert the shape of the raw json data.
     let response_text = res.text().await?;
 
@@ -193,7 +195,6 @@ async fn it_handles_malformed_json() -> Result<()> {
     assert_eq!(StatusCode::BAD_REQUEST, res.status());
 
     let response_text = res.text().await?;
-    println!("Response text: {:?}", response_text);
 
     assert!(
         response_text.contains("Failed to decode request: invalid JSON"),
@@ -400,7 +401,7 @@ async fn it_handles_flag_with_property_filter() -> Result<()> {
 }
 
 #[tokio::test]
-async fn it_handles_flag_with_group_properties() -> Result<()> {
+async fn it_matches_flags_to_a_request_with_group_property_overrides() -> Result<()> {
     let config = DEFAULT_TEST_CONFIG.clone();
     let distinct_id = "user_distinct_id".to_string();
 
@@ -500,3 +501,244 @@ async fn it_handles_flag_with_group_properties() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_feature_flags_with_json_payloads() -> Result<()> {
+    let config = DEFAULT_TEST_CONFIG.clone();
+    let distinct_id = "example_id".to_string();
+    let redis_client = setup_redis_client(Some(config.redis_url.clone()));
+    let pg_client = setup_pg_reader_client(None).await;
+
+    // Insert a new team into Redis and retrieve the team details
+    let team = insert_new_team_in_redis(redis_client.clone())
+        .await
+        .unwrap();
+    let token = team.api_token;
+
+    insert_new_team_in_pg(pg_client.clone(), Some(team.id))
+        .await
+        .unwrap();
+
+    insert_person_for_team_in_pg(
+        pg_client.clone(),
+        team.id,
+        distinct_id.clone(),
+        Some(json!({"email": "tim@posthog.com"})),
+    )
+    .await?;
+
+    let flag_json = json!([{
+        "id": 1,
+        "key": "filter-by-property",
+        "name": "Filter by property",
+        "active": true,
+        "deleted": false,
+        "team_id": team.id,
+        "filters": {
+            "groups": [
+                {
+                    "properties": [
+                        {
+                            "key": "email",
+                            "value": "tim@posthog.com",
+                            "operator": "exact",
+                            "type": "person",
+                        }
+                    ],
+                    "rollout_percentage": null,
+                }
+            ],
+            "payloads": {
+                "true": {
+                    "color": "blue"
+                }
+            },
+        },
+    }]);
+
+    insert_flags_for_team_in_redis(redis_client, team.id, Some(flag_json.to_string())).await?;
+
+    let server = ServerHandle::for_config(config).await;
+
+    let payload = json!({
+        "token": token,
+        "distinct_id": distinct_id,
+    });
+
+    let res = server.send_flags_request(payload.to_string()).await;
+
+    assert_eq!(StatusCode::OK, res.status());
+
+    let json_data = res.json::<Value>().await?;
+
+    assert_json_include!(
+        actual: json_data,
+        expected: json!({
+            "featureFlagPayloads": {
+                "filter-by-property": { "color": "blue" }
+            }
+        })
+    );
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_feature_flags_with_group_relationships() -> Result<()> {
+    let config = DEFAULT_TEST_CONFIG.clone();
+    let distinct_id = "example_id".to_string();
+    let redis_client = setup_redis_client(Some(config.redis_url.clone()));
+    let pg_client = setup_pg_reader_client(None).await;
+    let team_id = rand::thread_rng().gen_range(1..10_000_000);
+    let team = insert_new_team_in_pg(pg_client.clone(), Some(team_id))
+        .await
+        .unwrap();
+
+    let token = team.api_token;
+
+    // Create a group of type "organization" (group_type_index 1) with group_key "foo" and specific properties
+    create_group_in_pg(
+        pg_client.clone(),
+        team.id,
+        "organization",
+        "foo",
+        json!({"email": "posthog@example.com"}),
+    )
+    .await?;
+
+    // Create a group of type "project" (group_type_index 0) with group_key "bar" and specific properties
+    create_group_in_pg(
+        pg_client.clone(),
+        team.id,
+        "project",
+        "bar",
+        json!({"name": "Project Bar"}),
+    )
+    .await?;
+
+    // Define feature flags
+    let flags_json = json!([
+        {
+            "id": 1,
+            "key": "default-no-prop-group-flag",
+            "name": "This is a feature flag with default params, no filters.",
+            "active": true,
+            "deleted": false,
+            "team_id": team.id,
+            "filters": {
+                "aggregation_group_type_index": 0,
+                "groups": [{"rollout_percentage": null}]
+            }
+        },
+        {
+            "id": 2,
+            "key": "groups-flag",
+            "name": "This is a group-based flag",
+            "active": true,
+            "deleted": false,
+            "team_id": team.id,
+            "filters": {
+                "aggregation_group_type_index": 1,
+                "groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "email",
+                                "value": "posthog",
+                                "operator": "icontains",
+                                "type": "group",
+                                "group_type_index": 1
+                            }
+                        ],
+                        "rollout_percentage": null
+                    }
+                ]
+            }
+        }
+    ]);
+
+    // Insert the feature flags into Redis
+    insert_flags_for_team_in_redis(redis_client.clone(), team.id, Some(flags_json.to_string()))
+        .await?;
+
+    let server = ServerHandle::for_config(config).await;
+
+    // First Decision: Without specifying any groups
+    {
+        let payload = json!({
+            "token": token,
+            "distinct_id": distinct_id
+        });
+
+        let res = server.send_flags_request(payload.to_string()).await;
+        assert_eq!(res.status(), StatusCode::OK);
+
+        let json_data = res.json::<Value>().await?;
+        assert_json_include!(
+            actual: json_data,
+            expected: json!({
+                "errorWhileComputingFlags": false,
+                "featureFlags": {
+                    "default-no-prop-group-flag": false, // if we don't specify any groups in the request, the flags should be false
+                    "groups-flag": false
+                }
+            })
+        );
+    }
+
+    // Second Decision: With non-matching group overrides
+    {
+        let payload = json!({
+            "token": token,
+            "distinct_id": distinct_id,
+            "groups": {
+                "organization": "foo2", // Does not match existing group_key "foo"
+                "project": "bar"         // Matches existing project group
+            }
+        });
+
+        let res = server.send_flags_request(payload.to_string()).await;
+        assert_eq!(res.status(), StatusCode::OK);
+
+        let json_data = res.json::<Value>().await?;
+        assert_json_include!(
+            actual: json_data,
+            expected: json!({
+                "errorWhileComputingFlags": false,
+                "featureFlags": {
+                    "default-no-prop-group-flag": true,
+                    "groups-flag": false
+                }
+            })
+        );
+    }
+
+    // Third Decision: With matching group
+    {
+        let payload = json!({
+            "token": token,
+            "distinct_id": distinct_id,
+            "groups": {
+                "organization": "foo", // Matches existing group_key for organization "foo"
+                "project": "bar"       // Matches existing group_key for project "bar"
+            }
+        });
+
+        let res = server.send_flags_request(payload.to_string()).await;
+        assert_eq!(res.status(), StatusCode::OK);
+
+        let json_data = res.json::<Value>().await?;
+        assert_json_include!(
+            actual: json_data,
+            expected: json!({
+                "errorWhileComputingFlags": false,
+                "featureFlags": {
+                    "default-no-prop-group-flag": true,
+                    "groups-flag": true
+                }
+            })
+        );
+    }
+
+    Ok(())
+}
diff --git a/rust/property-defs-rs/.sqlx/query-04abdef9c07ae1a30bb6f22abcfb4dcdf2e218e48e0fd8a247e1b7ae0f04aee3.json b/rust/property-defs-rs/.sqlx/query-04abdef9c07ae1a30bb6f22abcfb4dcdf2e218e48e0fd8a247e1b7ae0f04aee3.json
new file mode 100644
index 0000000000000..5c8b96e695c28
--- /dev/null
+++ b/rust/property-defs-rs/.sqlx/query-04abdef9c07ae1a30bb6f22abcfb4dcdf2e218e48e0fd8a247e1b7ae0f04aee3.json
@@ -0,0 +1,21 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            INSERT INTO posthog_propertydefinition (id, name, type, group_type_index, is_numerical, volume_30_day, query_usage_30_day, team_id, project_id, property_type)\n            VALUES ($1, $2, $3, $4, $5, NULL, NULL, $6, $7, $8)\n            ON CONFLICT (team_id, name, type, coalesce(group_type_index, -1))\n            DO UPDATE SET property_type=EXCLUDED.property_type WHERE posthog_propertydefinition.property_type IS NULL\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Varchar",
+        "Int2",
+        "Int2",
+        "Bool",
+        "Int4",
+        "Int8",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "04abdef9c07ae1a30bb6f22abcfb4dcdf2e218e48e0fd8a247e1b7ae0f04aee3"
+}
diff --git a/rust/property-defs-rs/.sqlx/query-2b9a8c4b8d323e1673d805125b4073799ecba84594ca04cfb24481cffbf6f6ca.json b/rust/property-defs-rs/.sqlx/query-2b9a8c4b8d323e1673d805125b4073799ecba84594ca04cfb24481cffbf6f6ca.json
new file mode 100644
index 0000000000000..785a13a6d1ce7
--- /dev/null
+++ b/rust/property-defs-rs/.sqlx/query-2b9a8c4b8d323e1673d805125b4073799ecba84594ca04cfb24481cffbf6f6ca.json
@@ -0,0 +1,18 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            INSERT INTO posthog_eventdefinition (id, name, volume_30_day, query_usage_30_day, team_id, project_id, last_seen_at, created_at)\n            VALUES ($1, $2, NULL, NULL, $3, $4, $5, NOW()) ON CONFLICT\n            ON CONSTRAINT posthog_eventdefinition_team_id_name_80fa0b87_uniq\n            DO UPDATE SET last_seen_at = $5\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Varchar",
+        "Int4",
+        "Int8",
+        "Timestamptz"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "2b9a8c4b8d323e1673d805125b4073799ecba84594ca04cfb24481cffbf6f6ca"
+}
diff --git a/rust/property-defs-rs/.sqlx/query-9e0e25b9966a23792427c27a80888a75efdb8abe195339e0a1676ebed6fc61ef.json b/rust/property-defs-rs/.sqlx/query-9e0e25b9966a23792427c27a80888a75efdb8abe195339e0a1676ebed6fc61ef.json
new file mode 100644
index 0000000000000..f2582dca5c9b4
--- /dev/null
+++ b/rust/property-defs-rs/.sqlx/query-9e0e25b9966a23792427c27a80888a75efdb8abe195339e0a1676ebed6fc61ef.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO posthog_eventproperty (event, property, team_id, project_id) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int4",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "9e0e25b9966a23792427c27a80888a75efdb8abe195339e0a1676ebed6fc61ef"
+}
diff --git a/rust/property-defs-rs/.sqlx/query-c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee.json b/rust/property-defs-rs/.sqlx/query-c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee.json
new file mode 100644
index 0000000000000..608008e09adb5
--- /dev/null
+++ b/rust/property-defs-rs/.sqlx/query-c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT group_type_index FROM posthog_grouptypemapping WHERE group_type = $1 AND team_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "group_type_index",
+        "type_info": "Int4"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int4"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "c6ff00fcbbc77c8f5c1b3fe2f3352ea79485e403b9e17b6c37259ea0612065ee"
+}
diff --git a/rust/property-defs-rs/src/types.rs b/rust/property-defs-rs/src/types.rs
index 892ddcc4b5534..d437c62849f0e 100644
--- a/rust/property-defs-rs/src/types.rs
+++ b/rust/property-defs-rs/src/types.rs
@@ -84,6 +84,7 @@ impl GroupType {
 #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
 pub struct PropertyDefinition {
     pub team_id: i32,
+    pub project_id: i64,
     pub name: String,
     pub is_numerical: bool,
     pub property_type: Option<PropertyValueType>,
@@ -98,6 +99,7 @@ pub struct PropertyDefinition {
 pub struct EventDefinition {
     pub name: String,
     pub team_id: i32,
+    pub project_id: i64,
     pub last_seen_at: DateTime<Utc>, // Always floored to our update rate for last_seen, so this Eq derive is safe for deduping
 }
 
@@ -105,6 +107,7 @@ pub struct EventDefinition {
 #[derive(Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord)]
 pub struct EventProperty {
     pub team_id: i32,
+    pub project_id: i64,
     pub event: String,
     pub property: String,
 }
@@ -133,6 +136,7 @@ impl Update {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Event {
     pub team_id: i32,
+    pub project_id: i64,
     pub event: String,
     pub properties: Option<String>,
 }
@@ -142,6 +146,7 @@ impl From<&Event> for EventDefinition {
         EventDefinition {
             name: sanitize_event_name(&event.event),
             team_id: event.team_id,
+            project_id: event.project_id,
             // We round last seen to the nearest hour. Unwrap is safe here because we
             // the duration is positive, non-zero, and smaller than time since epoch. We use this
             // in the hash value, so updates which would modify this in the DB are issued even
@@ -261,6 +266,7 @@ impl Event {
 
             updates.push(Update::EventProperty(EventProperty {
                 team_id: self.team_id,
+                project_id: self.project_id,
                 event: self.event.clone(),
                 property: key.clone(),
             }));
@@ -270,6 +276,7 @@ impl Event {
 
             let def = PropertyDefinition {
                 team_id: self.team_id,
+                project_id: self.project_id,
                 name: key.clone(),
                 is_numerical,
                 property_type,
@@ -419,14 +426,15 @@ impl EventDefinition {
     {
         sqlx::query!(
             r#"
-            INSERT INTO posthog_eventdefinition (id, name, volume_30_day, query_usage_30_day, team_id, last_seen_at, created_at)
-            VALUES ($1, $2, NULL, NULL, $3, $4, NOW()) ON CONFLICT
+            INSERT INTO posthog_eventdefinition (id, name, volume_30_day, query_usage_30_day, team_id, project_id, last_seen_at, created_at)
+            VALUES ($1, $2, NULL, NULL, $3, $4, $5, NOW()) ON CONFLICT
             ON CONSTRAINT posthog_eventdefinition_team_id_name_80fa0b87_uniq
-            DO UPDATE SET last_seen_at = $4
+            DO UPDATE SET last_seen_at = $5
         "#,
             Uuid::now_v7(),
             self.name,
             self.team_id,
+            self.project_id,
             Utc::now() // We floor the update datetime to the nearest day for cache purposes, but can insert the exact time we see the event
         ).execute(executor).await.map(|_| ())
     }
@@ -462,8 +470,8 @@ impl PropertyDefinition {
 
         sqlx::query!(
             r#"
-            INSERT INTO posthog_propertydefinition (id, name, type, group_type_index, is_numerical, volume_30_day, query_usage_30_day, team_id, property_type)
-            VALUES ($1, $2, $3, $4, $5, NULL, NULL, $6, $7)
+            INSERT INTO posthog_propertydefinition (id, name, type, group_type_index, is_numerical, volume_30_day, query_usage_30_day, team_id, project_id, property_type)
+            VALUES ($1, $2, $3, $4, $5, NULL, NULL, $6, $7, $8)
             ON CONFLICT (team_id, name, type, coalesce(group_type_index, -1))
             DO UPDATE SET property_type=EXCLUDED.property_type WHERE posthog_propertydefinition.property_type IS NULL
         "#,
@@ -473,6 +481,7 @@ impl PropertyDefinition {
             group_type_index,
             self.is_numerical,
             self.team_id,
+            self.project_id,
             self.property_type.as_ref().map(|t| t.to_string())
         ).execute(executor).await.map(|_| ())
     }
@@ -484,10 +493,11 @@ impl EventProperty {
         E: Executor<'c, Database = Postgres>,
     {
         sqlx::query!(
-            r#"INSERT INTO posthog_eventproperty (event, property, team_id) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING"#,
+            r#"INSERT INTO posthog_eventproperty (event, property, team_id, project_id) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING"#,
             self.event,
             self.property,
-            self.team_id
+            self.team_id,
+            self.project_id
         )
         .execute(executor)
         .await
diff --git a/rust/property-defs-rs/tests/test_migrations/20240830124836_setup_propdefs_tables.sql b/rust/property-defs-rs/tests/test_migrations/20240830124836_setup_propdefs_tables.sql
index ec83e55a73dae..69b8e56b9e400 100644
--- a/rust/property-defs-rs/tests/test_migrations/20240830124836_setup_propdefs_tables.sql
+++ b/rust/property-defs-rs/tests/test_migrations/20240830124836_setup_propdefs_tables.sql
@@ -9,6 +9,7 @@ CREATE TABLE IF NOT EXISTS posthog_eventdefinition (
     volume_30_day INTEGER,
     query_usage_30_day INTEGER,
     team_id INTEGER NOT NULL,
+    project_id BIGINT NULL,
     last_seen_at TIMESTAMPTZ NOT NULL,
     created_at TIMESTAMPTZ NOT NULL,
     CONSTRAINT posthog_eventdefinition_team_id_name_80fa0b87_uniq UNIQUE (team_id, name)
@@ -24,6 +25,7 @@ CREATE TABLE IF NOT EXISTS posthog_propertydefinition (
     property_type_format VARCHAR(50),
     volume_30_day INTEGER,
     team_id INTEGER NOT NULL,
+    project_id BIGINT NULL,
     group_type_index SMALLINT,
     type SMALLINT NOT NULL DEFAULT 1
 );
@@ -35,7 +37,8 @@ CREATE TABLE IF NOT EXISTS posthog_eventproperty (
     id SERIAL PRIMARY KEY,
     event VARCHAR(400)NOT NULL,
     property VARCHAR(400) NOT NULL,
-    team_id INTEGER NOT NULL
+    team_id INTEGER NOT NULL,
+    project_id BIGINT NULL
 );
 
-CREATE UNIQUE INDEX posthog_event_property_unique_team_event_property ON posthog_eventproperty (team_id, event, property);
\ No newline at end of file
+CREATE UNIQUE INDEX posthog_event_property_unique_team_event_property ON posthog_eventproperty (team_id, event, property);
diff --git a/rust/property-defs-rs/tests/updates.rs b/rust/property-defs-rs/tests/updates.rs
index 773245a24dedd..8e78eeed00368 100644
--- a/rust/property-defs-rs/tests/updates.rs
+++ b/rust/property-defs-rs/tests/updates.rs
@@ -18,6 +18,7 @@ async fn test_updates(db: PgPool) {
 
     let event_src = json!({
         "team_id": 1,
+        "project_id": 1,
         "event": "update",
         "properties": properties
     });